Initial code commit

205 files changed, 80284 insertions, 0 deletions

diff --git a/src/Directory.Build.props b/src/Directory.Build.props
new file mode 100644
index 00000000..25cb6d36
--- /dev/null
+++ b/src/Directory.Build.props
@@ -0,0 +1,20 @@
+<?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>
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <BaseIntermediateOutputPath>$(MSBuildThisFileDirectory)..\build\obj\$(MSBuildProjectName)\</BaseIntermediateOutputPath>
+    <OutputPath>$(MSBuildThisFileDirectory)..\build\$(Configuration)\</OutputPath>
+
+    <Authors>WiX Toolset Team</Authors>
+    <Company>WiX Toolset</Company>
+    <Copyright>Copyright (c) .NET Foundation and contributors. All rights reserved.</Copyright>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <WixToolsetRootFolder>$(MSBuildThisFileDirectory)..\..\</WixToolsetRootFolder>
+  </PropertyGroup>
+
+  <Import Project="Custom.Build.props" Condition=" Exists('Custom.Build.props') " />
+</Project>
diff --git a/src/WixToolset.BuildTasks/AssemblyInfo.cs b/src/WixToolset.BuildTasks/AssemblyInfo.cs
new file mode 100644
index 00000000..ae52fce8
--- /dev/null
+++ b/src/WixToolset.BuildTasks/AssemblyInfo.cs
@@ -0,0 +1,7 @@
+// 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.
+
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+[assembly: AssemblyCulture("")]
+[assembly: ComVisible(false)]
diff --git a/src/WixToolset.BuildTasks/BuildException.cs b/src/WixToolset.BuildTasks/BuildException.cs
new file mode 100644
index 00000000..953134ba
--- /dev/null
+++ b/src/WixToolset.BuildTasks/BuildException.cs
@@ -0,0 +1,26 @@
+// 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.BuildTasks
+{
+    using System;
+    using System.Globalization;
+
+    class BuildException : Exception
+    {
+        public BuildException()
+        {
+        }
+
+        public BuildException(string message) : base(message)
+        {
+        }
+
+        public BuildException(string message, Exception innerException) : base(message, innerException)
+        {
+        }
+
+        public BuildException(string format, params string[] args) : this(String.Format(CultureInfo.CurrentCulture, format, args))
+        {
+        }
+    }
+}
diff --git a/src/WixToolset.BuildTasks/Candle.cs b/src/WixToolset.BuildTasks/Candle.cs
new file mode 100644
index 00000000..82b15838
--- /dev/null
+++ b/src/WixToolset.BuildTasks/Candle.cs
@@ -0,0 +1,199 @@
+// 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.BuildTasks
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Globalization;
+    using System.IO;
+    using System.Text;
+
+    using Microsoft.Build.Framework;
+    using Microsoft.Build.Utilities;
+
+    /// <summary>
+    /// An MSBuild task to run the WiX compiler.
+    /// </summary>
+    public sealed class CandleOld : WixToolTask
+    {
+        private const string CandleToolName = "candle.exe";
+
+        private string[] defineConstants;
+        private ITaskItem[] extensions;
+        private string[] includeSearchPaths;
+        private ITaskItem outputFile;
+        private bool pedantic;
+        private string installerPlatform;
+        private string preprocessToFile;
+        private bool preprocessToStdOut;
+        private ITaskItem[] sourceFiles;
+        private string extensionDirectory;
+        private string[] referencePaths;
+
+        public string[] DefineConstants
+        {
+            get { return this.defineConstants; }
+            set { this.defineConstants = value; }
+        }
+
+        public ITaskItem[] Extensions
+        {
+            get { return this.extensions; }
+            set { this.extensions = value; }
+        }
+
+        public string[] IncludeSearchPaths
+        {
+            get { return this.includeSearchPaths; }
+            set { this.includeSearchPaths = value; }
+        }
+
+        public string InstallerPlatform
+        {
+            get { return this.installerPlatform; }
+            set { this.installerPlatform = value; }
+        }
+
+        [Output]
+        [Required]
+        public ITaskItem OutputFile
+        {
+            get { return this.outputFile; }
+            set { this.outputFile = value; }
+        }
+
+        public bool Pedantic
+        {
+            get { return this.pedantic; }
+            set { this.pedantic = value; }
+        }
+
+        public string PreprocessToFile
+        {
+            get { return this.preprocessToFile; }
+            set { this.preprocessToFile = value; }
+        }
+
+        public bool PreprocessToStdOut
+        {
+            get { return this.preprocessToStdOut; }
+            set { this.preprocessToStdOut = value; }
+        }
+
+        [Required]
+        public ITaskItem[] SourceFiles
+        {
+            get { return this.sourceFiles; }
+            set { this.sourceFiles = value; }
+        }
+
+        public string ExtensionDirectory
+        {
+            get { return this.extensionDirectory; }
+            set { this.extensionDirectory = value; }
+        }
+
+        public string[] ReferencePaths
+        {
+            get { return this.referencePaths; }
+            set { this.referencePaths = value; }
+        }
+
+        /// <summary>
+        /// Get the name of the executable.
+        /// </summary>
+        /// <remarks>The ToolName is used with the ToolPath to get the location of candle.exe.</remarks>
+        /// <value>The name of the executable.</value>
+        protected override string ToolName
+        {
+            get { return CandleToolName; }
+        }
+
+        /// <summary>
+        /// Get the path to the executable.
+        /// </summary>
+        /// <remarks>GetFullPathToTool is only called when the ToolPath property is not set (see the ToolName remarks above).</remarks>
+        /// <returns>The full path to the executable or simply candle.exe if it's expected to be in the system path.</returns>
+        protected override string GenerateFullPathToTool()
+        {
+            // If there's not a ToolPath specified, it has to be in the system path.
+            if (String.IsNullOrEmpty(this.ToolPath))
+            {
+                return CandleToolName;
+            }
+
+            return Path.Combine(Path.GetFullPath(this.ToolPath), CandleToolName);
+        }
+
+        /// <summary>
+        /// Builds a command line from options in this task.
+        /// </summary>
+        protected override void BuildCommandLine(WixCommandLineBuilder commandLineBuilder)
+        {
+            base.BuildCommandLine(commandLineBuilder);
+
+            commandLineBuilder.AppendIfTrue("-p", this.PreprocessToStdOut);
+            commandLineBuilder.AppendSwitchIfNotNull("-p", this.PreprocessToFile);
+            commandLineBuilder.AppendSwitchIfNotNull("-out ", this.OutputFile);
+            commandLineBuilder.AppendArrayIfNotNull("-d", this.DefineConstants);
+            commandLineBuilder.AppendArrayIfNotNull("-I", this.IncludeSearchPaths);
+            commandLineBuilder.AppendIfTrue("-pedantic", this.Pedantic);
+            commandLineBuilder.AppendSwitchIfNotNull("-arch ", this.InstallerPlatform);
+            commandLineBuilder.AppendExtensions(this.Extensions, this.ExtensionDirectory, this.referencePaths);
+            commandLineBuilder.AppendTextIfNotNull(this.AdditionalOptions);
+
+            // Support per-source-file output by looking at the SourceFiles items to
+            // see if there is any "CandleOutput" metadata.  If there is, we do our own
+            // appending, otherwise we fall back to the built-in "append file names" code.
+            // Note also that the wix.targets "Compile" target does *not* automagically
+            // fix the "@(CompileObjOutput)" list to include these new output names.
+            // If you really want to use this, you're going to have to clone the target
+            // in your own .targets file and create the output list yourself.
+            bool usePerSourceOutput = false;
+            if (this.SourceFiles != null)
+            {
+                foreach (ITaskItem item in this.SourceFiles)
+                {
+                    if (!String.IsNullOrEmpty(item.GetMetadata("CandleOutput")))
+                    {
+                        usePerSourceOutput = true;
+                        break;
+                    }
+                }
+            }
+
+            if (usePerSourceOutput)
+            {
+                string[] newSourceNames = new string[this.SourceFiles.Length];
+                for (int iSource = 0; iSource < this.SourceFiles.Length; ++iSource)
+                {
+                    ITaskItem item = this.SourceFiles[iSource];
+                    if (null == item)
+                    {
+                        newSourceNames[iSource] = null;
+                    }
+                    else
+                    {
+                        string output = item.GetMetadata("CandleOutput");
+
+                        if (!String.IsNullOrEmpty(output))
+                        {
+                            newSourceNames[iSource] = String.Concat(item.ItemSpec, ";", output);
+                        }
+                        else
+                        {
+                            newSourceNames[iSource] = item.ItemSpec;
+                        }
+                    }
+                }
+
+                commandLineBuilder.AppendFileNamesIfNotNull(newSourceNames, " ");
+            }
+            else
+            {
+                commandLineBuilder.AppendFileNamesIfNotNull(this.SourceFiles, " ");
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.BuildTasks/Common.cs b/src/WixToolset.BuildTasks/Common.cs
new file mode 100644
index 00000000..803e9d14
--- /dev/null
+++ b/src/WixToolset.BuildTasks/Common.cs
@@ -0,0 +1,41 @@
+// 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
+{
+    using System;
+    using System.Globalization;
+    using System.Text;
+    using System.Text.RegularExpressions;
+
+    /// <summary>
+    /// Common WixTasks utility methods and types.
+    /// </summary>
+    internal static class Common
+    {
+        /// <summary>Metadata key name to turn off harvesting of project references.</summary>
+        public const string DoNotHarvest = "DoNotHarvest";
+
+        private static readonly Regex AddPrefix = new Regex(@"^[^a-zA-Z_]", RegexOptions.Compiled);
+        private static readonly Regex IllegalIdentifierCharacters = new Regex(@"[^A-Za-z0-9_\.]|\.{2,}", RegexOptions.Compiled); // non 'words' and assorted valid characters
+
+        /// <summary>
+        /// Return an identifier based on passed file/directory name
+        /// </summary>
+        /// <param name="name">File/directory name to generate identifer from</param>
+        /// <returns>A version of the name that is a legal identifier.</returns>
+        /// <remarks>This is duplicated from WiX's Common class.</remarks>
+        internal static string GetIdentifierFromName(string name)
+        {
+            string result = IllegalIdentifierCharacters.Replace(name, "_"); // replace illegal characters with "_".
+
+            // MSI identifiers must begin with an alphabetic character or an
+            // underscore. Prefix all other values with an underscore.
+            if (AddPrefix.IsMatch(name))
+            {
+                result = String.Concat("_", result);
+            }
+
+            return result;
+        }
+    }
+}
diff --git a/src/WixToolset.BuildTasks/ConvertReferences.cs b/src/WixToolset.BuildTasks/ConvertReferences.cs
new file mode 100644
index 00000000..fe137633
--- /dev/null
+++ b/src/WixToolset.BuildTasks/ConvertReferences.cs
@@ -0,0 +1,93 @@
+// 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.BuildTasks
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.IO;
+    using System.Xml;
+    using Microsoft.Build.Framework;
+    using Microsoft.Build.Utilities;
+
+    /// <summary>
+    /// This task assigns Culture metadata to files based on the value of the Culture attribute on the
+    /// WixLocalization element inside the file.
+    /// </summary>
+    public class ConvertReferences : Task
+    {
+        private string projectOutputGroups;
+        private ITaskItem[] projectReferences;
+        private ITaskItem[] harvestItems;
+
+        /// <summary>
+        /// The total list of cabs in this database
+        /// </summary>
+        [Output]
+        public ITaskItem[] HarvestItems
+        {
+            get { return this.harvestItems; }
+        }
+
+        /// <summary>
+        /// The project output groups to harvest.
+        /// </summary>
+        [Required]
+        public string ProjectOutputGroups
+        {
+            get { return this.projectOutputGroups; }
+            set { this.projectOutputGroups = value; }
+        }
+
+        /// <summary>
+        /// All the project references in the project.
+        /// </summary>
+        [Required]
+        public ITaskItem[] ProjectReferences
+        {
+            get { return this.projectReferences; }
+            set { this.projectReferences = value; }
+        }
+
+        /// <summary>
+        /// Gets a complete list of external cabs referenced by the given installer database file.
+        /// </summary>
+        /// <returns>True upon completion of the task execution.</returns>
+        public override bool Execute()
+        {
+            List<ITaskItem> newItems = new List<ITaskItem>();
+
+            foreach(ITaskItem item in this.ProjectReferences)
+            {
+                Dictionary<string, string> newItemMetadeta = new Dictionary<string, string>();
+
+                if (!String.IsNullOrEmpty(item.GetMetadata(Common.DoNotHarvest)))
+                {
+                    continue;
+                }
+
+                string refTargetDir = item.GetMetadata("RefTargetDir");
+                if (!String.IsNullOrEmpty(refTargetDir))
+                {
+                    newItemMetadeta.Add("DirectoryIds", refTargetDir);
+                }
+
+                string refName = item.GetMetadata("Name");
+                if (!String.IsNullOrEmpty(refName))
+                {
+                    newItemMetadeta.Add("ProjectName", refName);
+                }
+
+                newItemMetadeta.Add("ProjectOutputGroups", this.ProjectOutputGroups);
+
+                ITaskItem newItem = new TaskItem(item.ItemSpec, newItemMetadeta);
+                newItems.Add(newItem);
+            }
+
+            this.harvestItems = newItems.ToArray();
+
+            return true;
+        }
+    }
+}
diff --git a/src/WixToolset.BuildTasks/CreateItemAvoidingInference.cs b/src/WixToolset.BuildTasks/CreateItemAvoidingInference.cs
new file mode 100644
index 00000000..84816cac
--- /dev/null
+++ b/src/WixToolset.BuildTasks/CreateItemAvoidingInference.cs
@@ -0,0 +1,60 @@
+// 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.BuildTasks
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.IO;
+    using System.Xml;
+    using Microsoft.Build.Framework;
+    using Microsoft.Build.Utilities;
+
+    /// <summary>
+    /// This task assigns Culture metadata to files based on the value of the Culture attribute on the
+    /// WixLocalization element inside the file.
+    /// </summary>
+    public class CreateItemAvoidingInference : Task
+    {
+        private string inputProperties;
+        private ITaskItem[] outputItems;
+
+        /// <summary>
+        /// The output items.
+        /// </summary>
+        [Output]
+        public ITaskItem[] OuputItems
+        {
+            get { return this.outputItems; }
+        }
+
+        /// <summary>
+        /// The properties to converty to items.
+        /// </summary>
+        [Required]
+        public string InputProperties
+        {
+            get { return this.inputProperties; }
+            set { this.inputProperties = value; }
+        }
+
+        /// <summary>
+        /// Gets a complete list of external cabs referenced by the given installer database file.
+        /// </summary>
+        /// <returns>True upon completion of the task execution.</returns>
+        public override bool Execute()
+        {
+            List<ITaskItem> newItems = new List<ITaskItem>();
+
+            foreach (string property in this.inputProperties.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries))
+            {
+                newItems.Add(new TaskItem(property));
+            }
+
+            this.outputItems = newItems.ToArray();
+
+            return true;
+        }
+    }
+}
diff --git a/src/WixToolset.BuildTasks/CreateProjectReferenceDefineConstants.cs b/src/WixToolset.BuildTasks/CreateProjectReferenceDefineConstants.cs
new file mode 100644
index 00000000..5eae0850
--- /dev/null
+++ b/src/WixToolset.BuildTasks/CreateProjectReferenceDefineConstants.cs
@@ -0,0 +1,270 @@
+// 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.BuildTasks
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.IO;
+    using Microsoft.Build.Framework;
+    using Microsoft.Build.Utilities;
+
+    /// <summary>
+    /// An MSBuild task to create a list of preprocessor defines to be passed to candle from the
+    /// list of referenced projects.
+    /// </summary>
+    public sealed class CreateProjectReferenceDefineConstants : Task
+    {
+        private ITaskItem[] defineConstants;
+        private ITaskItem[] projectConfigurations;
+        private ITaskItem[] projectReferencePaths;
+
+        [Output]
+        public ITaskItem[] DefineConstants
+        {
+            get { return this.defineConstants; }
+        }
+
+        [Required]
+        public ITaskItem[] ProjectReferencePaths
+        {
+            get { return this.projectReferencePaths; }
+            set { this.projectReferencePaths = value; }
+        }
+
+        public ITaskItem[] ProjectConfigurations
+        {
+            get { return this.projectConfigurations; }
+            set { this.projectConfigurations = value; }
+        }
+
+        public override bool Execute()
+        {
+            List<ITaskItem> outputItems = new List<ITaskItem>();
+            Dictionary<string, string> defineConstants = new Dictionary<string, string>();
+
+            for (int i = 0; i < this.ProjectReferencePaths.Length; i++)
+            {
+                ITaskItem item = this.ProjectReferencePaths[i];
+
+                string configuration = item.GetMetadata("Configuration");
+                string fullConfiguration = item.GetMetadata("FullConfiguration");
+                string platform = item.GetMetadata("Platform");
+
+                string projectPath = CreateProjectReferenceDefineConstants.GetProjectPath(this.ProjectReferencePaths, i);
+                string projectDir = Path.GetDirectoryName(projectPath) + Path.DirectorySeparatorChar;
+                string projectExt = Path.GetExtension(projectPath);
+                string projectFileName = Path.GetFileName(projectPath);
+                string projectName = Path.GetFileNameWithoutExtension(projectPath);
+
+                string referenceName = CreateProjectReferenceDefineConstants.GetReferenceName(item, projectName);
+
+                string targetPath = item.GetMetadata("FullPath");
+                string targetDir = Path.GetDirectoryName(targetPath) + Path.DirectorySeparatorChar;
+                string targetExt = Path.GetExtension(targetPath);
+                string targetFileName = Path.GetFileName(targetPath);
+                string targetName = Path.GetFileNameWithoutExtension(targetPath);
+
+                // If there is no configuration metadata on the project reference task item,
+                // check for any additional configuration data provided in the optional task property.
+                if (String.IsNullOrEmpty(fullConfiguration))
+                {
+                    fullConfiguration = this.FindProjectConfiguration(projectName);
+                    if (!String.IsNullOrEmpty(fullConfiguration))
+                    {
+                        string[] typeAndPlatform = fullConfiguration.Split('|');
+                        configuration = typeAndPlatform[0];
+                        platform = (typeAndPlatform.Length > 1 ? typeAndPlatform[1] : String.Empty);
+                    }
+                }
+
+                // write out the platform/configuration defines
+                defineConstants[String.Format(CultureInfo.InvariantCulture, "{0}.Configuration", referenceName)] = configuration;
+                defineConstants[String.Format(CultureInfo.InvariantCulture, "{0}.FullConfiguration", referenceName)] = fullConfiguration;
+                defineConstants[String.Format(CultureInfo.InvariantCulture, "{0}.Platform", referenceName)] = platform;
+
+                // write out the ProjectX defines
+                defineConstants[String.Format(CultureInfo.InvariantCulture, "{0}.ProjectDir", referenceName)] = projectDir;
+                defineConstants[String.Format(CultureInfo.InvariantCulture, "{0}.ProjectExt", referenceName)] = projectExt;
+                defineConstants[String.Format(CultureInfo.InvariantCulture, "{0}.ProjectFileName", referenceName)] = projectFileName;
+                defineConstants[String.Format(CultureInfo.InvariantCulture, "{0}.ProjectName", referenceName)] = projectName;
+                defineConstants[String.Format(CultureInfo.InvariantCulture, "{0}.ProjectPath", referenceName)] = projectPath;
+
+                // write out the TargetX defines
+                string targetDirDefine = String.Format(CultureInfo.InvariantCulture, "{0}.TargetDir", referenceName);
+                if (defineConstants.ContainsKey(targetDirDefine))
+                {
+                    //if target dir was already defined, redefine it as the common root shared by multiple references from the same project
+                    string commonDir = FindCommonRoot(targetDir, defineConstants[targetDirDefine]);
+                    if (!String.IsNullOrEmpty(commonDir))
+                    {
+                        targetDir = commonDir;
+                    }
+                }
+                defineConstants[targetDirDefine] = CreateProjectReferenceDefineConstants.EnsureEndsWithBackslash(targetDir);
+
+                defineConstants[String.Format(CultureInfo.InvariantCulture, "{0}.TargetExt", referenceName)] = targetExt;
+                defineConstants[String.Format(CultureInfo.InvariantCulture, "{0}.TargetFileName", referenceName)] = targetFileName;
+                defineConstants[String.Format(CultureInfo.InvariantCulture, "{0}.TargetName", referenceName)] = targetName;
+
+                //if target path was already defined, append to it creating a list of multiple references from the same project
+                string targetPathDefine = String.Format(CultureInfo.InvariantCulture, "{0}.TargetPath", referenceName);
+                if (defineConstants.ContainsKey(targetPathDefine))
+                {
+                    string oldTargetPath = defineConstants[targetPathDefine];
+                    if (!targetPath.Equals(oldTargetPath, StringComparison.OrdinalIgnoreCase))
+                    {
+                        defineConstants[targetPathDefine] += ";" + targetPath;
+                    }
+
+                    //If there was only one targetpath we need to create its culture specific define
+                    if (!oldTargetPath.Contains(";"))
+                    {
+                        string oldSubFolder = FindSubfolder(oldTargetPath, targetDir, targetFileName);
+                        if (!String.IsNullOrEmpty(oldSubFolder))
+                        {
+                            defineConstants[String.Format(CultureInfo.InvariantCulture, "{0}.{1}.TargetPath", referenceName, oldSubFolder.Replace('\\', '_'))] = oldTargetPath;
+                        }
+                    }
+
+                    // Create a culture specific define
+                    string subFolder = FindSubfolder(targetPath, targetDir, targetFileName);
+                    if (!String.IsNullOrEmpty(subFolder))
+                    {
+                        defineConstants[String.Format(CultureInfo.InvariantCulture, "{0}.{1}.TargetPath", referenceName, subFolder.Replace('\\', '_'))] = targetPath;
+                    }
+
+                }
+                else
+                {
+                    defineConstants[targetPathDefine] = targetPath;
+                }
+            }
+
+            foreach (KeyValuePair<string, string> define in defineConstants)
+            {
+                outputItems.Add(new TaskItem(String.Format(CultureInfo.InvariantCulture, "{0}={1}", define.Key, define.Value)));
+            }
+            this.defineConstants = outputItems.ToArray();
+
+            return true;
+        }
+
+        public static string GetProjectPath(ITaskItem[] projectReferencePaths, int i)
+        {
+            return projectReferencePaths[i].GetMetadata("MSBuildSourceProjectFile");
+        }
+
+        public static string GetReferenceName(ITaskItem item, string projectName)
+        {
+            string referenceName = item.GetMetadata("Name");
+            if (String.IsNullOrEmpty(referenceName))
+            {
+                referenceName = projectName;
+            }
+
+            // We cannot have an equals sign in the variable name because it
+            // messes with the preprocessor definitions on the command line.
+            referenceName = referenceName.Replace('=', '_');
+
+            // We cannot have a double quote on the command line because it
+            // there is no way to escape it on the command line.
+            referenceName = referenceName.Replace('\"', '_');
+
+            // We cannot have parens in the variable name because the WiX
+            // preprocessor will not be able to parse it.
+            referenceName = referenceName.Replace('(', '_');
+            referenceName = referenceName.Replace(')', '_');
+
+            return referenceName;
+        }
+
+        /// <summary>
+        /// Look through the configuration data in the ProjectConfigurations property
+        /// to find the configuration for a project, if available.
+        /// </summary>
+        /// <param name="projectName">Name of the project that is being searched for.</param>
+        /// <returns>Full configuration spec, for example "Release|Win32".</returns>
+        private string FindProjectConfiguration(string projectName)
+        {
+            string configuration = String.Empty;
+
+            if (this.ProjectConfigurations != null)
+            {
+                foreach (ITaskItem configItem in this.ProjectConfigurations)
+                {
+                    string configProject = configItem.ItemSpec;
+                    if (configProject.Length > projectName.Length &&
+                        configProject.StartsWith(projectName) &&
+                        configProject[projectName.Length] == '=')
+                    {
+                        configuration = configProject.Substring(projectName.Length + 1);
+                        break;
+                    }
+                }
+            }
+
+            return configuration;
+        }
+
+        /// <summary>
+        /// Finds the common root between two paths
+        /// </summary>
+        /// <param name="path1"></param>
+        /// <param name="path2"></param>
+        /// <returns>common root on success, empty string on failure</returns>
+        private static string FindCommonRoot(string path1, string path2)
+        {
+            path1 = path1.TrimEnd(Path.DirectorySeparatorChar);
+            path2 = path2.TrimEnd(Path.DirectorySeparatorChar);
+
+            while (!String.IsNullOrEmpty(path1))
+            {
+                for (string searchPath = path2; !String.IsNullOrEmpty(searchPath); searchPath = Path.GetDirectoryName(searchPath))
+                {
+                    if (path1.Equals(searchPath, StringComparison.OrdinalIgnoreCase))
+                    {
+                        return searchPath;
+                    }
+                }
+
+                path1 = Path.GetDirectoryName(path1);
+            }
+
+            return path1;
+        }
+
+        /// <summary>
+        /// Finds the subfolder of a path, excluding a root and filename.
+        /// </summary>
+        /// <param name="path">Path to examine</param>
+        /// <param name="rootPath">Root that must be present </param>
+        /// <param name="fileName"></param>
+        /// <returns></returns>
+        private static string FindSubfolder(string path, string rootPath, string fileName)
+        {
+            if (Path.GetFileName(path).Equals(fileName, StringComparison.OrdinalIgnoreCase))
+            {
+                path = Path.GetDirectoryName(path);
+            }
+
+            if (path.StartsWith(rootPath, StringComparison.OrdinalIgnoreCase))
+            {
+                // cut out the root and return the subpath
+                return path.Substring(rootPath.Length).Trim(Path.DirectorySeparatorChar);
+            }
+
+            return String.Empty;
+        }
+
+        private static string EnsureEndsWithBackslash(string dir)
+        {
+            if (dir[dir.Length - 1] != Path.DirectorySeparatorChar)
+            {
+                dir += Path.DirectorySeparatorChar;
+            }
+
+            return dir;
+        }
+    }
+}
diff --git a/src/WixToolset.BuildTasks/DoIt-Compile.cs b/src/WixToolset.BuildTasks/DoIt-Compile.cs
new file mode 100644
index 00000000..f89078fe
--- /dev/null
+++ b/src/WixToolset.BuildTasks/DoIt-Compile.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.
+
+#if false
+namespace WixToolset.BuildTasks
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using Microsoft.Build.Framework;
+    using WixToolset.Data;
+
+    /// <summary>
+    /// An MSBuild task to run the WiX compiler.
+    /// </summary>
+    public sealed class Candle : TaskBase
+    {
+        public string[] DefineConstants { get; set; }
+
+        public ITaskItem[] Extensions { get; set; }
+
+        public string[] IncludeSearchPaths { get; set; }
+
+        public string InstallerPlatform { get; set; }
+
+        [Output]
+        [Required]
+        public ITaskItem OutputFile { get; set; }
+
+        public bool Pedantic { get; set; }
+
+        public string PreprocessToFile { get; set; }
+
+        public bool PreprocessToStdOut { get; set; }
+
+        [Required]
+        public ITaskItem IntermediateDirectory { get; set; }
+
+        [Required]
+        public ITaskItem[] SourceFiles { get; set; }
+
+        public string ExtensionDirectory { get; set; }
+
+        public string[] ReferencePaths { get; set; }
+
+        protected override void ExecuteCore()
+        {
+            Messaging.Instance.InitializeAppName("WIX", "wix.exe");
+
+            Messaging.Instance.Display += this.DisplayMessage;
+
+            var preprocessor = new Preprocessor();
+
+            var compiler = new Compiler();
+
+            var sourceFiles = this.GatherSourceFiles();
+
+            var preprocessorVariables = this.GatherPreprocessorVariables();
+
+            foreach (var sourceFile in sourceFiles)
+            {
+                var document = preprocessor.Process(sourceFile.SourcePath, preprocessorVariables);
+
+                var intermediate = compiler.Compile(document);
+
+                intermediate.Save(sourceFile.OutputPath);
+            }
+        }
+
+        private void DisplayMessage(object sender, DisplayEventArgs e)
+        {
+            this.Log.LogMessageFromText(e.Message, MessageImportance.Normal);
+        }
+
+        private IEnumerable<SourceFile> GatherSourceFiles()
+        {
+            var files = new List<SourceFile>();
+
+            foreach (var item in this.SourceFiles)
+            {
+                var sourcePath = item.ItemSpec;
+                var outputPath = item.GetMetadata("CandleOutput") ?? this.OutputFile?.ItemSpec;
+
+                if (String.IsNullOrEmpty(outputPath))
+                {
+                    outputPath = Path.Combine(this.IntermediateDirectory.ItemSpec, Path.GetFileNameWithoutExtension(sourcePath) + ".wir");
+                }
+
+                files.Add(new SourceFile(sourcePath, outputPath));
+            }
+
+            return files;
+        }
+
+        private IDictionary<string, string> GatherPreprocessorVariables()
+        {
+            var variables = new Dictionary<string, string>();
+
+            foreach (var pair in this.DefineConstants)
+            {
+                string[] value = pair.Split(new[] { '=' }, 2);
+
+                if (variables.ContainsKey(value[0]))
+                {
+                    //Messaging.Instance.OnMessage(WixErrors.DuplicateVariableDefinition(value[0], (1 == value.Length) ? String.Empty : value[1], this.PreprocessorVariables[value[0]]));
+                    break;
+                }
+
+                if (1 == value.Length)
+                {
+                    variables.Add(value[0], String.Empty);
+                }
+                else
+                {
+                    variables.Add(value[0], value[1]);
+                }
+            }
+
+            return variables;
+        }
+
+        ///// <summary>
+        ///// Builds a command line from options in this task.
+        ///// </summary>
+        //protected override void BuildCommandLine(WixCommandLineBuilder commandLineBuilder)
+        //{
+        //    base.BuildCommandLine(commandLineBuilder);
+
+        //    commandLineBuilder.AppendIfTrue("-p", this.PreprocessToStdOut);
+        //    commandLineBuilder.AppendSwitchIfNotNull("-p", this.PreprocessToFile);
+        //    commandLineBuilder.AppendSwitchIfNotNull("-out ", this.OutputFile);
+        //    commandLineBuilder.AppendArrayIfNotNull("-d", this.DefineConstants);
+        //    commandLineBuilder.AppendArrayIfNotNull("-I", this.IncludeSearchPaths);
+        //    commandLineBuilder.AppendIfTrue("-pedantic", this.Pedantic);
+        //    commandLineBuilder.AppendSwitchIfNotNull("-arch ", this.InstallerPlatform);
+        //    commandLineBuilder.AppendExtensions(this.Extensions, this.ExtensionDirectory, this.referencePaths);
+        //    commandLineBuilder.AppendTextIfNotNull(this.AdditionalOptions);
+
+        //    // Support per-source-file output by looking at the SourceFiles items to
+        //    // see if there is any "CandleOutput" metadata.  If there is, we do our own
+        //    // appending, otherwise we fall back to the built-in "append file names" code.
+        //    // Note also that the wix.targets "Compile" target does *not* automagically
+        //    // fix the "@(CompileObjOutput)" list to include these new output names.
+        //    // If you really want to use this, you're going to have to clone the target
+        //    // in your own .targets file and create the output list yourself.
+        //    bool usePerSourceOutput = false;
+        //    if (this.SourceFiles != null)
+        //    {
+        //        foreach (ITaskItem item in this.SourceFiles)
+        //        {
+        //            if (!String.IsNullOrEmpty(item.GetMetadata("CandleOutput")))
+        //            {
+        //                usePerSourceOutput = true;
+        //                break;
+        //            }
+        //        }
+        //    }
+
+        //    if (usePerSourceOutput)
+        //    {
+        //        string[] newSourceNames = new string[this.SourceFiles.Length];
+        //        for (int iSource = 0; iSource < this.SourceFiles.Length; ++iSource)
+        //        {
+        //            ITaskItem item = this.SourceFiles[iSource];
+        //            if (null == item)
+        //            {
+        //                newSourceNames[iSource] = null;
+        //            }
+        //            else
+        //            {
+        //                string output = item.GetMetadata("CandleOutput");
+
+        //                if (!String.IsNullOrEmpty(output))
+        //                {
+        //                    newSourceNames[iSource] = String.Concat(item.ItemSpec, ";", output);
+        //                }
+        //                else
+        //                {
+        //                    newSourceNames[iSource] = item.ItemSpec;
+        //                }
+        //            }
+        //        }
+
+        //        commandLineBuilder.AppendFileNamesIfNotNull(newSourceNames, " ");
+        //    }
+        //    else
+        //    {
+        //        commandLineBuilder.AppendFileNamesIfNotNull(this.SourceFiles, " ");
+        //    }
+        //}
+    }
+}
+#endif
diff --git a/src/WixToolset.BuildTasks/DoIt.cs b/src/WixToolset.BuildTasks/DoIt.cs
new file mode 100644
index 00000000..7688342c
--- /dev/null
+++ b/src/WixToolset.BuildTasks/DoIt.cs
@@ -0,0 +1,233 @@
+// 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.BuildTasks
+{
+    using Microsoft.Build.Framework;
+    using Microsoft.Build.Utilities;
+    using WixToolset.Core;
+    using WixToolset.Data;
+
+    /// <summary>
+    /// An MSBuild task to run the WiX compiler.
+    /// </summary>
+    public sealed class DoIt : Task
+    {
+        public DoIt()
+        {
+            Messaging.Instance.InitializeAppName("WIX", "wix.exe");
+
+            Messaging.Instance.Display += this.DisplayMessage;
+        }
+
+        public string AdditionalOptions { get; set; }
+
+        public string Cultures { get; set; }
+
+        public string[] DefineConstants { get; set; }
+
+        public ITaskItem[] Extensions { get; set; }
+
+        public string ExtensionDirectory { get; set; }
+
+        public string[] IncludeSearchPaths { get; set; }
+
+        public string InstallerPlatform { get; set; }
+
+        [Required]
+        public ITaskItem IntermediateDirectory { get; set; }
+
+        public ITaskItem[] LocalizationFiles { get; set; }
+
+        public bool NoLogo { get; set; }
+
+        public ITaskItem[] ObjectFiles { get; set; }
+
+        [Output]
+        [Required]
+        public ITaskItem OutputFile { get; set; }
+
+        public string PdbOutputFile { get; set; }
+
+        public bool Pedantic { get; set; }
+
+        [Required]
+        public ITaskItem[] SourceFiles { get; set; }
+
+        public string[] ReferencePaths { get; set; }
+
+
+        /// <summary>
+        /// Gets or sets whether all warnings should be suppressed.
+        /// </summary>
+        public bool SuppressAllWarnings { get; set; }
+
+        /// <summary>
+        /// Gets or sets a list of specific warnings to be suppressed.
+        /// </summary>
+        public string[] SuppressSpecificWarnings { get; set; }
+
+        /// <summary>
+        /// Gets or sets whether all warnings should be treated as errors.
+        /// </summary>
+        public bool TreatWarningsAsErrors { get; set; }
+
+        /// <summary>
+        /// Gets or sets a list of specific warnings to treat as errors.
+        /// </summary>
+        public string[] TreatSpecificWarningsAsErrors { get; set; }
+
+        /// <summary>
+        /// Gets or sets whether to display verbose output.
+        /// </summary>
+        public bool VerboseOutput { get; set; }
+
+
+        public ITaskItem[] BindInputPaths { get; set; }
+        public bool BindFiles { get; set; }
+        public ITaskItem BindContentsFile{ get; set; }
+        public ITaskItem BindOutputsFile { get; set; }
+        public ITaskItem BindBuiltOutputsFile { get; set; }
+
+        public string CabinetCachePath { get; set; }
+        public int CabinetCreationThreadCount { get; set; }
+        public string DefaultCompressionLevel { get; set; }
+
+        [Output]
+        public ITaskItem UnreferencedSymbolsFile { get; set; }
+
+        public ITaskItem WixProjectFile { get; set; }
+        public string[] WixVariables { get; set; }
+
+        public bool SuppressValidation { get; set; }
+        public string[] SuppressIces { get; set; }
+        public string AdditionalCub { get; set; }
+
+
+
+        public override bool Execute()
+        {
+            try
+            {
+                this.ExecuteCore();
+            }
+            catch (BuildException e)
+            {
+                this.Log.LogErrorFromException(e);
+            }
+            catch (WixException e)
+            {
+                this.Log.LogErrorFromException(e);
+            }
+
+            return !this.Log.HasLoggedErrors;
+        }
+
+        private void ExecuteCore()
+        {
+            var commandLineBuilder = new WixCommandLineBuilder();
+
+            commandLineBuilder.AppendTextUnquoted("build");
+
+            commandLineBuilder.AppendSwitchIfNotNull("-out ", this.OutputFile);
+            commandLineBuilder.AppendSwitchIfNotNull("-cultures ", this.Cultures);
+            commandLineBuilder.AppendArrayIfNotNull("-d ", this.DefineConstants);
+            commandLineBuilder.AppendArrayIfNotNull("-I ", this.IncludeSearchPaths);
+            commandLineBuilder.AppendExtensions(this.Extensions, this.ExtensionDirectory, this.ReferencePaths);
+            commandLineBuilder.AppendIfTrue("-nologo", this.NoLogo);
+            commandLineBuilder.AppendIfTrue("-sval", this.SuppressValidation);
+            commandLineBuilder.AppendArrayIfNotNull("-sice ", this.SuppressIces);
+            commandLineBuilder.AppendSwitchIfNotNull("-usf ", this.UnreferencedSymbolsFile);
+            commandLineBuilder.AppendSwitchIfNotNull("-cc ", this.CabinetCachePath);
+            commandLineBuilder.AppendSwitchIfNotNull("-contentsfile ", this.BindContentsFile);
+            commandLineBuilder.AppendSwitchIfNotNull("-outputsfile ", this.BindOutputsFile);
+            commandLineBuilder.AppendSwitchIfNotNull("-builtoutputsfile ", this.BindBuiltOutputsFile);
+            commandLineBuilder.AppendSwitchIfNotNull("-wixprojectfile ", this.WixProjectFile);
+            commandLineBuilder.AppendTextIfNotWhitespace(this.AdditionalOptions);
+
+            commandLineBuilder.AppendArrayIfNotNull("-loc ", this.LocalizationFiles);
+            commandLineBuilder.AppendFileNamesIfNotNull(this.SourceFiles, " ");
+
+            var commandLineString = commandLineBuilder.ToString();
+
+            this.Log.LogMessage(MessageImportance.Normal, commandLineString);
+
+            var command = CommandLine.ParseStandardCommandLine(commandLineString);
+            command?.Execute();
+        }
+
+        private void DisplayMessage(object sender, DisplayEventArgs e)
+        {
+            this.Log.LogMessageFromText(e.Message, MessageImportance.Normal);
+        }
+
+        ///// <summary>
+        ///// Builds a command line from options in this task.
+        ///// </summary>
+        //protected override void BuildCommandLine(WixCommandLineBuilder commandLineBuilder)
+        //{
+        //    base.BuildCommandLine(commandLineBuilder);
+
+        //    commandLineBuilder.AppendIfTrue("-p", this.PreprocessToStdOut);
+        //    commandLineBuilder.AppendSwitchIfNotNull("-p", this.PreprocessToFile);
+        //    commandLineBuilder.AppendSwitchIfNotNull("-out ", this.OutputFile);
+        //    commandLineBuilder.AppendArrayIfNotNull("-d", this.DefineConstants);
+        //    commandLineBuilder.AppendArrayIfNotNull("-I", this.IncludeSearchPaths);
+        //    commandLineBuilder.AppendIfTrue("-pedantic", this.Pedantic);
+        //    commandLineBuilder.AppendSwitchIfNotNull("-arch ", this.InstallerPlatform);
+        //    commandLineBuilder.AppendExtensions(this.Extensions, this.ExtensionDirectory, this.referencePaths);
+        //    commandLineBuilder.AppendTextIfNotNull(this.AdditionalOptions);
+
+        //    // Support per-source-file output by looking at the SourceFiles items to
+        //    // see if there is any "CandleOutput" metadata.  If there is, we do our own
+        //    // appending, otherwise we fall back to the built-in "append file names" code.
+        //    // Note also that the wix.targets "Compile" target does *not* automagically
+        //    // fix the "@(CompileObjOutput)" list to include these new output names.
+        //    // If you really want to use this, you're going to have to clone the target
+        //    // in your own .targets file and create the output list yourself.
+        //    bool usePerSourceOutput = false;
+        //    if (this.SourceFiles != null)
+        //    {
+        //        foreach (ITaskItem item in this.SourceFiles)
+        //        {
+        //            if (!String.IsNullOrEmpty(item.GetMetadata("CandleOutput")))
+        //            {
+        //                usePerSourceOutput = true;
+        //                break;
+        //            }
+        //        }
+        //    }
+
+        //    if (usePerSourceOutput)
+        //    {
+        //        string[] newSourceNames = new string[this.SourceFiles.Length];
+        //        for (int iSource = 0; iSource < this.SourceFiles.Length; ++iSource)
+        //        {
+        //            ITaskItem item = this.SourceFiles[iSource];
+        //            if (null == item)
+        //            {
+        //                newSourceNames[iSource] = null;
+        //            }
+        //            else
+        //            {
+        //                string output = item.GetMetadata("CandleOutput");
+
+        //                if (!String.IsNullOrEmpty(output))
+        //                {
+        //                    newSourceNames[iSource] = String.Concat(item.ItemSpec, ";", output);
+        //                }
+        //                else
+        //                {
+        //                    newSourceNames[iSource] = item.ItemSpec;
+        //                }
+        //            }
+        //        }
+
+        //        commandLineBuilder.AppendFileNamesIfNotNull(newSourceNames, " ");
+        //    }
+        //    else
+        //    {
+        //        commandLineBuilder.AppendFileNamesIfNotNull(this.SourceFiles, " ");
+        //    }
+        //}
+    }
+}
diff --git a/src/WixToolset.BuildTasks/FileSearchHelperMethods.cs b/src/WixToolset.BuildTasks/FileSearchHelperMethods.cs
new file mode 100644
index 00000000..6cc804eb
--- /dev/null
+++ b/src/WixToolset.BuildTasks/FileSearchHelperMethods.cs
@@ -0,0 +1,60 @@
+// 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.BuildTasks
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics.CodeAnalysis;
+    using System.IO;
+    using System.Text;
+    using Microsoft.Build.Framework;
+
+    /// <summary>
+    /// Contains helper methods on searching for files
+    /// </summary>
+    public static class FileSearchHelperMethods
+    {
+        /// <summary>
+        /// Searches for the existence of a file in multiple directories. 
+        /// Search is satisfied if default file path is valid and exists. If not,
+        /// file name is extracted from default path and combined with each of the directories
+        /// looking to see if it exists. If not found, input default path is returned.
+        /// </summary>
+        /// <param name="directories">Array of directories to look in, without filenames in them</param>
+        /// <param name="defaultFullPath">Default path - to use if not found</param>
+        /// <returns>File path if file found. Empty string if not found</returns>
+        public static string SearchFilePaths(string[] directories, string defaultFullPath)
+        {
+            if (String.IsNullOrEmpty(defaultFullPath))
+            {
+                return String.Empty;
+            }
+
+            if (File.Exists(defaultFullPath))
+            {
+                return defaultFullPath;
+            }
+
+            if (directories == null)
+            {
+                return string.Empty;
+            }
+
+            string fileName = Path.GetFileName(defaultFullPath);
+            foreach (string currentPath in directories)
+            {
+                if (String.IsNullOrEmpty(currentPath) || String.IsNullOrEmpty(currentPath.Trim()))
+                {
+                    continue;
+                }
+
+                if (File.Exists(Path.Combine(currentPath, fileName)))
+                {
+                    return Path.Combine(currentPath, fileName);
+                }
+            }
+
+            return String.Empty;
+        }
+    }
+}
diff --git a/src/WixToolset.BuildTasks/GenerateCompileWithObjectPath.cs b/src/WixToolset.BuildTasks/GenerateCompileWithObjectPath.cs
new file mode 100644
index 00000000..06c8b98a
--- /dev/null
+++ b/src/WixToolset.BuildTasks/GenerateCompileWithObjectPath.cs
@@ -0,0 +1,146 @@
+// 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.BuildTasks
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Globalization;
+    using System.IO;
+    using System.Security.Cryptography;
+    using System.Text;
+    using Microsoft.Build.Framework;
+    using Microsoft.Build.Utilities;
+
+    /// <summary>
+    /// This task generates metadata on the for compile output objects.
+    /// </summary>
+    public class GenerateCompileWithObjectPath : Task
+    {
+        /// <summary>
+        /// The list of files to generate outputs for.
+        /// </summary>
+        [Required]
+        public ITaskItem[] Compile
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// The list of files with ObjectPath metadata.
+        /// </summary>
+        [Output]
+        public ITaskItem[] CompileWithObjectPath
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// The folder under which all ObjectPaths should reside.
+        /// </summary>
+        [Required]
+        public string IntermediateOutputPath
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Generate an identifier by hashing data from the row.
+        /// </summary>
+        /// <param name="prefix">Three letter or less prefix for generated row identifier.</param>
+        /// <param name="args">Information to hash.</param>
+        /// <returns>The generated identifier.</returns>
+        [SuppressMessage("Microsoft.Globalization", "CA1303:DoNotPassLiteralsAsLocalizedParameters", MessageId = "System.InvalidOperationException.#ctor(System.String)")]
+        public static string GenerateIdentifier(string prefix, params string[] args)
+        {
+            string stringData = String.Join("|", args);
+            byte[] data = Encoding.Unicode.GetBytes(stringData);
+
+            // hash the data
+            byte[] hash;
+
+            using (MD5 md5 = new MD5CryptoServiceProvider())
+            {
+                hash = md5.ComputeHash(data);
+            }
+
+            // build up the identifier
+            StringBuilder identifier = new StringBuilder(35, 35);
+            identifier.Append(prefix);
+
+            // hard coded to 16 as that is the most bytes that can be used to meet the length requirements. SHA1 is 20 bytes.
+            for (int i = 0; i < 16; i++)
+            {
+                identifier.Append(hash[i].ToString("X2", CultureInfo.InvariantCulture.NumberFormat));
+            }
+
+            return identifier.ToString();
+        }
+
+        /// <summary>
+        /// Gets the full path of the directory in which the file is found.
+        /// </summary>
+        /// <param name='file'>The file from which to extract the directory.</param>
+        /// <returns>The generated identifier.</returns>
+        private static string GetDirectory(ITaskItem file)
+        {
+            return file.GetMetadata("RootDir") + file.GetMetadata("Directory");
+        }
+
+        /// <summary>
+        /// Sets the object path to use for the file.
+        /// </summary>
+        /// <param name='file'>The file on which to set the ObjectPath metadata.</param>
+        /// <remarks>
+        /// For the same input path it will return the same ObjectPath. Case is not ignored, however that isn't a problem.
+        /// </remarks>
+        private void SetObjectPath(ITaskItem file)
+        {
+            // If the source file is in the project directory or in the intermediate directory, use the intermediate directory.
+            if (string.IsNullOrEmpty(file.GetMetadata("RelativeDir")) || string.Compare(file.GetMetadata("RelativeDir"), this.IntermediateOutputPath, StringComparison.OrdinalIgnoreCase) == 0)
+            {
+                file.SetMetadata("ObjectPath", this.IntermediateOutputPath);
+            }
+            // Otherwise use a subdirectory of the intermediate directory. The subfolder's name is based on the full path of the folder containing the source file.
+            else
+            {
+                file.SetMetadata("ObjectPath", Path.Combine(this.IntermediateOutputPath, GenerateIdentifier("pth", GetDirectory(file))) + Path.DirectorySeparatorChar);
+            }
+        }
+
+        /// <summary>
+        /// Gets a complete list of external cabs referenced by the given installer database file.
+        /// </summary>
+        /// <returns>True upon completion of the task execution.</returns>
+        public override bool Execute()
+        {
+            if (string.IsNullOrEmpty(this.IntermediateOutputPath))
+            {
+                this.Log.LogError("IntermediateOutputPath parameter is required and cannot be empty");
+                return false;
+            }
+
+            if (this.Compile == null || this.Compile.Length == 0)
+            {
+                return true;
+            }
+
+            this.CompileWithObjectPath = new ITaskItem[this.Compile.Length];
+            for (int i = 0; i < this.Compile.Length; ++i)
+            {
+                this.CompileWithObjectPath[i] = new TaskItem(this.Compile[i].ItemSpec, this.Compile[i].CloneCustomMetadata());
+
+                // Do not overwrite the ObjectPath metadata if it already was set.
+                if (string.IsNullOrEmpty(this.CompileWithObjectPath[i].GetMetadata("ObjectPath")))
+                {
+                    SetObjectPath(this.CompileWithObjectPath[i]);
+                }
+            }
+
+            return true;
+        }
+    }
+}
diff --git a/src/WixToolset.BuildTasks/GetCabList.cs b/src/WixToolset.BuildTasks/GetCabList.cs
new file mode 100644
index 00000000..e97538af
--- /dev/null
+++ b/src/WixToolset.BuildTasks/GetCabList.cs
@@ -0,0 +1,87 @@
+// 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.BuildTasks
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.IO;
+    using System.Reflection;
+    using System.Xml;
+    using Microsoft.Build.Framework;
+    using Microsoft.Build.Utilities;
+    using WixToolset.Dtf.WindowsInstaller;
+    using Microsoft.Win32;
+
+    /// <summary>
+    /// This task assigns Culture metadata to files based on the value of the Culture attribute on the
+    /// WixLocalization element inside the file.
+    /// </summary>
+    public class GetCabList : Task
+    {
+        private ITaskItem database;
+        private ITaskItem[] cabList;
+
+        /// <summary>
+        /// The list of database files to find cabs in
+        /// </summary>
+        [Required]
+        public ITaskItem Database
+        {
+            get { return this.database; }
+            set { this.database = value; }
+        }
+
+        /// <summary>
+        /// The total list of cabs in this database
+        /// </summary>
+        [Output]
+        public ITaskItem[] CabList
+        {
+            get { return this.cabList; }
+        }
+
+        /// <summary>
+        /// Gets a complete list of external cabs referenced by the given installer database file.
+        /// </summary>
+        /// <returns>True upon completion of the task execution.</returns>
+        public override bool Execute()
+        {
+            string databaseFile = this.database.ItemSpec;
+            Object []args = { };
+            System.Collections.Generic.List<ITaskItem> cabNames = new System.Collections.Generic.List<ITaskItem>();
+
+            // If the file doesn't exist, no cabs to return, so exit now
+            if (!File.Exists(databaseFile))
+            {
+                return true;
+            }
+
+            using (Database database = new Database(databaseFile))
+            {
+                // If the media table doesn't exist, no cabs to return, so exit now
+                if (null == database.Tables["Media"])
+                {
+                    return true;
+                }
+
+                System.Collections.IList records = database.ExecuteQuery("SELECT `Cabinet` FROM `Media`", args);
+
+                foreach (string cabName in records)
+                {
+                    if (String.IsNullOrEmpty(cabName) || cabName.StartsWith("#", StringComparison.Ordinal))
+                    {
+                        continue;
+                    }
+
+                    cabNames.Add(new TaskItem(Path.Combine(Path.GetDirectoryName(databaseFile), cabName)));
+                }
+            }
+
+            this.cabList = cabNames.ToArray();
+
+            return true;
+        }
+    }
+}
diff --git a/src/WixToolset.BuildTasks/GetLooseFileList.cs b/src/WixToolset.BuildTasks/GetLooseFileList.cs
new file mode 100644
index 00000000..bd403426
--- /dev/null
+++ b/src/WixToolset.BuildTasks/GetLooseFileList.cs
@@ -0,0 +1,230 @@
+// 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.BuildTasks
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.IO;
+    using System.Reflection;
+    using System.Xml;
+    using Microsoft.Build.Framework;
+    using Microsoft.Build.Utilities;
+    using WixToolset.Dtf.WindowsInstaller;
+    using Microsoft.Win32;
+
+    /// <summary>
+    /// This task assigns Culture metadata to files based on the value of the Culture attribute on the
+    /// WixLocalization element inside the file.
+    /// </summary>
+    public class GetLooseFileList : Task
+    {
+        private ITaskItem database;
+        private ITaskItem[] looseFileList;
+
+        internal const int MsidbFileAttributesNoncompressed = 8192;
+        internal const int MsidbFileAttributesCompressed = 16384;
+
+        /// <summary>
+        /// The list of database files to find Loose Files in
+        /// </summary>
+        [Required]
+        public ITaskItem Database
+        {
+            get { return this.database; }
+            set { this.database = value; }
+        }
+
+        /// <summary>
+        /// The total list of Loose Files in this database
+        /// </summary>
+        [Output]
+        public ITaskItem[] LooseFileList
+        {
+            get { return this.looseFileList; }
+        }
+
+        /// <summary>
+        /// Takes the "defaultDir" column
+        /// </summary>
+        /// <returns>Returns the corresponding sourceDir.</returns>
+        public string SourceDirFromDefaultDir(string defaultDir)
+        {
+            string sourceDir;
+
+            string[] splitted = defaultDir.Split(':');
+
+            if (1 == splitted.Length)
+            {
+                sourceDir = splitted[0];
+            }
+            else
+            {
+                sourceDir = splitted[1];
+            }
+
+            splitted = sourceDir.Split('|');
+
+            if (1 == splitted.Length)
+            {
+                sourceDir = splitted[0];
+            }
+            else
+            {
+                sourceDir = splitted[1];
+            }
+
+            return sourceDir;
+        }
+
+        /// <summary>
+        /// Takes the "FileName" column
+        /// </summary>
+        /// <returns>Returns the corresponding source file name.</returns>
+        public string SourceFileFromFileName(string fileName)
+        {
+            string sourceFile;
+
+            string[] splitted = fileName.Split('|');
+
+            if (1 == splitted.Length)
+            {
+                sourceFile = splitted[0];
+            }
+            else
+            {
+                sourceFile = splitted[1];
+            }
+
+            return sourceFile;
+        }
+
+        /// <summary>
+        /// Gets a complete list of external Loose Files referenced by the given installer database file.
+        /// </summary>
+        /// <returns>True upon completion of the task execution.</returns>
+        public override bool Execute()
+        {
+            string databaseFile = this.database.ItemSpec;
+            Object []emptyArgs = { };
+            System.Collections.Generic.List<ITaskItem> looseFileNames = new System.Collections.Generic.List<ITaskItem>();
+            Dictionary<string, string> ComponentFullDirectory = new Dictionary<string, string>();
+            Dictionary<string, string> DirectoryIdDefaultDir = new Dictionary<string, string>();
+            Dictionary<string, string> DirectoryIdParent = new Dictionary<string, string>();
+            Dictionary<string, string> DirectoryIdFullSource = new Dictionary<string, string>();
+            int i;
+            string databaseDir = Path.GetDirectoryName(databaseFile);
+
+            // If the file doesn't exist, no Loose Files to return, so exit now
+            if (!File.Exists(databaseFile))
+            {
+                return true;
+            }
+
+            using (Database database = new Database(databaseFile))
+            {
+                bool compressed = false;
+                if (2 == (database.SummaryInfo.WordCount & 2))
+                {
+                    compressed = true;
+                }
+
+                // If the media table doesn't exist, no Loose Files to return, so exit now
+                if (null == database.Tables["File"])
+                {
+                    return true;
+                }
+
+                // Only setup all these helpful indexes if the database is marked as uncompressed. If it's marked as compressed, files are stored at the root,
+                // so none of these indexes will be used
+                if (!compressed)
+                {
+                    if (null == database.Tables["Directory"] || null == database.Tables["Component"])
+                    {
+                        return true;
+                    }
+
+                    System.Collections.IList directoryRecords = database.ExecuteQuery("SELECT `Directory`,`Directory_Parent`,`DefaultDir` FROM `Directory`", emptyArgs);
+
+                    // First setup a simple index from DirectoryId to DefaultDir
+                    for (i = 0; i < directoryRecords.Count; i += 3)
+                    {
+                        string directoryId = (string)(directoryRecords[i]);
+                        string directoryParent = (string)(directoryRecords[i + 1]);
+                        string defaultDir = (string)(directoryRecords[i + 2]);
+
+                        string sourceDir = SourceDirFromDefaultDir(defaultDir);
+
+                        DirectoryIdDefaultDir[directoryId] = sourceDir;
+                        DirectoryIdParent[directoryId] = directoryParent;
+                    }
+
+                    // Setup an index from directory Id to the full source path
+                    for (i = 0; i < directoryRecords.Count; i += 3)
+                    {
+                        string directoryId = (string)(directoryRecords[i]);
+                        string directoryParent = (string)(directoryRecords[i + 1]);
+                        string defaultDir = (string)(directoryRecords[i + 2]);
+
+                        string sourceDir = DirectoryIdDefaultDir[directoryId];
+
+                        // The TARGETDIR case
+                        if (String.IsNullOrEmpty(directoryParent))
+                        {
+                            DirectoryIdFullSource[directoryId] = databaseDir;
+                        }
+                        else
+                        {
+                            string tempDirectoryParent = directoryParent;
+
+                            while (!String.IsNullOrEmpty(tempDirectoryParent) && !String.IsNullOrEmpty(DirectoryIdParent[tempDirectoryParent]))
+                            {
+                                sourceDir = Path.Combine(DirectoryIdDefaultDir[tempDirectoryParent], sourceDir);
+
+                                tempDirectoryParent = DirectoryIdParent[tempDirectoryParent];
+                            }
+
+                            DirectoryIdFullSource[directoryId] = Path.Combine(databaseDir, sourceDir);
+                        }
+                    }
+
+                    // Setup an index from component Id to full directory path
+                    System.Collections.IList componentRecords = database.ExecuteQuery("SELECT `Component`,`Directory_` FROM `Component`", emptyArgs);
+
+                    for (i = 0; i < componentRecords.Count; i += 2)
+                    {
+                        string componentId = (string)(componentRecords[i]);
+                        string componentDir = (string)(componentRecords[i + 1]);
+
+                        ComponentFullDirectory[componentId] = DirectoryIdFullSource[componentDir];
+                    }
+                }
+
+                System.Collections.IList fileRecords = database.ExecuteQuery("SELECT `Component_`,`FileName`,`Attributes` FROM `File`", emptyArgs);
+
+                for (i = 0; i < fileRecords.Count; i += 3)
+                {
+                    string componentId = (string)(fileRecords[i]);
+                    string fileName = SourceFileFromFileName((string)(fileRecords[i + 1]));
+                    int attributes = (int)(fileRecords[i + 2]);
+
+                    // If the whole database is marked uncompressed, use the directory layout made above
+                    if ((!compressed && MsidbFileAttributesCompressed != (attributes & MsidbFileAttributesCompressed)))
+                    {
+                        looseFileNames.Add(new TaskItem(Path.GetFullPath(Path.Combine(ComponentFullDirectory[componentId], fileName))));
+                    }
+                    // If the database is marked as compressed, put files at the root
+                    else if (compressed && (MsidbFileAttributesNoncompressed == (attributes & MsidbFileAttributesNoncompressed)))
+                    {
+                        looseFileNames.Add(new TaskItem(Path.GetFullPath(Path.Combine(databaseDir, fileName))));
+                    }
+                }
+            }
+
+            this.looseFileList = looseFileNames.ToArray();
+
+            return true;
+        }
+    }
+}
diff --git a/src/WixToolset.BuildTasks/GlobalSuppressions.cs b/src/WixToolset.BuildTasks/GlobalSuppressions.cs
new file mode 100644
index 00000000..65c34c13
--- /dev/null
+++ b/src/WixToolset.BuildTasks/GlobalSuppressions.cs
@@ -0,0 +1,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.
+
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "WixToolset")]
+
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Msi", Scope = "namespace", Target = "WixToolset.BuildTasks")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "wix")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Wix")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "wix")]
diff --git a/src/WixToolset.BuildTasks/Insignia.cs b/src/WixToolset.BuildTasks/Insignia.cs
new file mode 100644
index 00000000..ba30963a
--- /dev/null
+++ b/src/WixToolset.BuildTasks/Insignia.cs
@@ -0,0 +1,118 @@
+// 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.BuildTasks
+{
+    using System;
+    using System.Diagnostics;
+    using System.Globalization;
+    using System.IO;
+    using System.Text;
+
+    using Microsoft.Build.Framework;
+    using Microsoft.Build.Utilities;
+
+    /// <summary>
+    /// An MSBuild task to run the WiX transform generator.
+    /// </summary>
+    public sealed class Insignia : WixToolTask
+    {
+        private const string InsigniaToolName = "insignia.exe";
+
+        /// <summary>
+        /// Gets or sets the path to the database to inscribe.
+        /// </summary>
+        public ITaskItem DatabaseFile { get; set; }
+
+        /// <summary>
+        /// Gets or sets the path to the bundle to inscribe.
+        /// </summary>
+        public ITaskItem BundleFile { get; set; }
+
+        /// <summary>
+        /// Gets or sets the path to the original bundle that contains the attached container.
+        /// </summary>
+        public ITaskItem OriginalBundleFile { get; set; }
+
+        /// <summary>
+        /// Gets or sets the path to output the inscribed result.
+        /// </summary>
+        [Required]
+        public ITaskItem OutputFile { get; set; }
+
+        /// <summary>
+        /// Gets or sets the output. Only set if insignia does work.
+        /// </summary>
+        [Output]
+        public ITaskItem Output { get; set; }
+
+        /// <summary>
+        /// Get the name of the executable.
+        /// </summary>
+        /// <remarks>The ToolName is used with the ToolPath to get the location of Insignia.exe.</remarks>
+        /// <value>The name of the executable.</value>
+        protected override string ToolName
+        {
+            get { return InsigniaToolName; }
+        }
+
+        /// <summary>
+        /// Get the path to the executable. 
+        /// </summary>
+        /// <remarks>GetFullPathToTool is only called when the ToolPath property is not set (see the ToolName remarks above).</remarks>
+        /// <returns>The full path to the executable or simply Insignia.exe if it's expected to be in the system path.</returns>
+        protected override string GenerateFullPathToTool()
+        {
+            // If there's not a ToolPath specified, it has to be in the system path.
+            if (String.IsNullOrEmpty(this.ToolPath))
+            {
+                return InsigniaToolName;
+            }
+
+            return Path.Combine(Path.GetFullPath(this.ToolPath), InsigniaToolName);
+        }
+
+        /// <summary>
+        /// Builds a command line from options in this task.
+        /// </summary>
+        protected override void BuildCommandLine(WixCommandLineBuilder commandLineBuilder)
+        {
+            base.BuildCommandLine(commandLineBuilder);
+
+            commandLineBuilder.AppendSwitchIfNotNull("-im ", this.DatabaseFile);
+            if (null != this.OriginalBundleFile)
+            {
+                commandLineBuilder.AppendSwitchIfNotNull("-ab ", this.BundleFile);
+                commandLineBuilder.AppendFileNameIfNotNull(this.OriginalBundleFile);
+            }
+            else
+            {
+                commandLineBuilder.AppendSwitchIfNotNull("-ib ", this.BundleFile);
+            }
+
+            commandLineBuilder.AppendSwitchIfNotNull("-out ", this.OutputFile);
+            commandLineBuilder.AppendTextIfNotNull(this.AdditionalOptions);
+        }
+
+        /// <summary>
+        /// Executes a tool in-process by loading the tool assembly and invoking its entrypoint.
+        /// </summary>
+        /// <param name="pathToTool">Path to the tool to be executed; must be a managed executable.</param>
+        /// <param name="responseFileCommands">Commands to be written to a response file.</param>
+        /// <param name="commandLineCommands">Commands to be passed directly on the command-line.</param>
+        /// <returns>The tool exit code.</returns>
+        protected override int ExecuteTool(string pathToTool, string responseFileCommands, string commandLineCommands)
+        {
+            int returnCode = base.ExecuteTool(pathToTool, responseFileCommands, commandLineCommands);
+            if (0 == returnCode) // successfully did work.
+            {
+                this.Output = this.OutputFile;
+            }
+            else if (-1 == returnCode) // no work done.
+            {
+                returnCode = 0;
+            }
+
+            return returnCode;
+        }
+    }
+}
diff --git a/src/WixToolset.BuildTasks/Light.cs b/src/WixToolset.BuildTasks/Light.cs
new file mode 100644
index 00000000..b7d0b4f7
--- /dev/null
+++ b/src/WixToolset.BuildTasks/Light.cs
@@ -0,0 +1,488 @@
+// 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.BuildTasks
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Globalization;
+    using System.IO;
+    using System.Text;
+
+    using Microsoft.Build.Framework;
+    using Microsoft.Build.Utilities;
+
+    /// <summary>
+    /// An MSBuild task to run the WiX linker.
+    /// </summary>
+    public sealed class Light : WixToolTask
+    {
+        private const string LightToolName = "Light.exe";
+
+        private string additionalCub;
+        private bool allowIdenticalRows;
+        private bool allowUnresolvedReferences;
+        private string[] baseInputPaths;
+        private ITaskItem[] bindInputPaths;
+        private bool backwardsCompatibleGuidGeneration;
+        private bool bindFiles;
+        private ITaskItem builtOutputsFile;
+        private string cabinetCachePath;
+        private int cabinetCreationThreadCount = WixCommandLineBuilder.Unspecified;
+        private ITaskItem contentsFile;
+        private string cultures;
+        private string customBinder;
+        private string defaultCompressionLevel;
+        private ITaskItem[] extensions;
+        private string[] ices;
+        private bool leaveTemporaryFiles;
+        private ITaskItem[] localizationFiles;
+        private ITaskItem[] objectFiles;
+        private bool outputAsXml;
+        private ITaskItem outputsFile;
+        private ITaskItem outputFile;
+        private ITaskItem pdbOutputFile;
+        private ITaskItem wixProjectFile;
+        private bool pedantic;
+        private bool reuseCabinetCache;
+        private bool suppressAclReset;
+        private bool suppressAssemblies;
+        private bool suppressDefaultAdminSequenceActions;
+        private bool suppressDefaultAdvSequenceActions;
+        private bool suppressDefaultUISequenceActions;
+        private bool dropUnrealTables;
+        private bool exactAssemblyVersions;
+        private bool suppressFileHashAndInfo;
+        private bool suppressFiles;
+        private bool suppressIntermediateFileVersionMatching;
+        private string[] suppressIces;
+        private bool suppressLayout;
+        private bool suppressLocalization;
+        private bool suppressMsiAssemblyTableProcessing;
+        private bool suppressPdbOutput;
+        private bool suppressSchemaValidation;
+        private bool suppressValidation;
+        private bool suppressTagSectionIdAttributeOnTuples;
+        private ITaskItem unreferencedSymbolsFile;
+        private string[] wixVariables;
+        private string extensionDirectory;
+        private string[] referencePaths;
+
+        /// <summary>
+        /// Creates a new light task.
+        /// </summary>
+        /// <remarks>
+        /// Defaults to running the task as a separate process, instead of in-proc
+        /// which is the default for WixToolTasks. This allows the Win32 manifest file
+        /// embedded in light.exe to enable reg-free COM interop with mergemod.dll.
+        /// </remarks>
+        public Light()
+        {
+        }
+
+        public string AdditionalCub
+        {
+            get { return this.additionalCub; }
+            set { this.additionalCub = value; }
+        }
+
+        public bool AllowIdenticalRows
+        {
+            get { return this.allowIdenticalRows; }
+            set { this.allowIdenticalRows = value; }
+        }
+
+        public bool AllowUnresolvedReferences
+        {
+            get { return this.allowUnresolvedReferences; }
+            set { this.allowUnresolvedReferences = value; }
+        }
+
+        // TODO: remove this property entirely in v4.0
+        [Obsolete("Use BindInputPaths instead of BaseInputPaths.")]
+        public string[] BaseInputPaths
+        {
+            get { return this.baseInputPaths; }
+            set { this.baseInputPaths = value; }
+        }
+
+        public ITaskItem[] BindInputPaths
+        {
+            get { return this.bindInputPaths; }
+            set { this.bindInputPaths = value; }
+        }
+
+        public bool BackwardsCompatibleGuidGeneration
+        {
+            get { return this.backwardsCompatibleGuidGeneration; }
+            set { this.backwardsCompatibleGuidGeneration = value; }
+        }
+
+        public bool BindFiles
+        {
+            get { return this.bindFiles; }
+            set { this.bindFiles = value; }
+        }
+
+        public string CabinetCachePath
+        {
+            get { return this.cabinetCachePath; }
+            set { this.cabinetCachePath = value; }
+        }
+
+        public int CabinetCreationThreadCount
+        {
+            get { return this.cabinetCreationThreadCount; }
+            set { this.cabinetCreationThreadCount = value; }
+        }
+
+        public ITaskItem BindBuiltOutputsFile
+        {
+            get { return this.builtOutputsFile; }
+            set { this.builtOutputsFile = value; }
+        }
+
+        public ITaskItem BindContentsFile
+        {
+            get { return this.contentsFile; }
+            set { this.contentsFile = value; }
+        }
+
+        public ITaskItem BindOutputsFile
+        {
+            get { return this.outputsFile; }
+            set { this.outputsFile = value; }
+        }
+
+        public string Cultures
+        {
+            get { return this.cultures; }
+            set { this.cultures = value; }
+        }
+
+        public string CustomBinder
+        {
+            get { return this.customBinder; }
+            set { this.customBinder = value; }
+        }
+
+        public string DefaultCompressionLevel
+        {
+            get { return this.defaultCompressionLevel; }
+            set { this.defaultCompressionLevel = value; }
+        }
+
+        public bool DropUnrealTables
+        {
+            get { return this.dropUnrealTables; }
+            set { this.dropUnrealTables = value; }
+        }
+
+        public bool ExactAssemblyVersions
+        {
+            get { return this.exactAssemblyVersions; }
+            set { this.exactAssemblyVersions = value; }
+        }
+
+        public ITaskItem[] Extensions
+        {
+            get { return this.extensions; }
+            set { this.extensions = value; }
+        }
+
+        public string[] Ices
+        {
+            get { return this.ices; }
+            set { this.ices = value; }
+        }
+
+        public bool LeaveTemporaryFiles
+        {
+            get { return this.leaveTemporaryFiles; }
+            set { this.leaveTemporaryFiles = value; }
+        }
+
+        public ITaskItem[] LocalizationFiles
+        {
+            get { return this.localizationFiles; }
+            set { this.localizationFiles = value; }
+        }
+
+        [Required]
+        public ITaskItem[] ObjectFiles
+        {
+            get { return this.objectFiles; }
+            set { this.objectFiles = value; }
+        }
+
+        public bool OutputAsXml
+        {
+            get { return this.outputAsXml; }
+            set { this.outputAsXml = value; }
+        }
+
+        [Required]
+        [Output]
+        public ITaskItem OutputFile
+        {
+            get { return this.outputFile; }
+            set { this.outputFile = value; }
+        }
+
+        [Output]
+        public ITaskItem PdbOutputFile
+        {
+            get { return this.pdbOutputFile; }
+            set { this.pdbOutputFile = value; }
+        }
+
+        public bool Pedantic
+        {
+            get { return this.pedantic; }
+            set { this.pedantic = value; }
+        }
+
+        public bool ReuseCabinetCache
+        {
+            get { return this.reuseCabinetCache; }
+            set { this.reuseCabinetCache = value; }
+        }
+
+        public bool SuppressAclReset
+        {
+            get { return this.suppressAclReset; }
+            set { this.suppressAclReset = value; }
+        }
+
+        public bool SuppressAssemblies
+        {
+            get { return this.suppressAssemblies; }
+            set { this.suppressAssemblies = value; }
+        }
+
+        public bool SuppressDefaultAdminSequenceActions
+        {
+            get { return this.suppressDefaultAdminSequenceActions; }
+            set { this.suppressDefaultAdminSequenceActions = value; }
+        }
+
+        public bool SuppressDefaultAdvSequenceActions
+        {
+            get { return this.suppressDefaultAdvSequenceActions; }
+            set { this.suppressDefaultAdvSequenceActions = value; }
+        }
+
+        public bool SuppressDefaultUISequenceActions
+        {
+            get { return this.suppressDefaultUISequenceActions; }
+            set { this.suppressDefaultUISequenceActions = value; }
+        }
+
+        public bool SuppressFileHashAndInfo
+        {
+            get { return this.suppressFileHashAndInfo; }
+            set { this.suppressFileHashAndInfo = value; }
+        }
+
+        public bool SuppressFiles
+        {
+            get { return this.suppressFiles; }
+            set { this.suppressFiles = value; }
+        }
+
+        public bool SuppressIntermediateFileVersionMatching
+        {
+            get { return this.suppressIntermediateFileVersionMatching; }
+            set { this.suppressIntermediateFileVersionMatching = value; }
+        }
+
+        public string[] SuppressIces
+        {
+            get { return this.suppressIces; }
+            set { this.suppressIces = value; }
+        }
+
+        public bool SuppressLayout
+        {
+            get { return this.suppressLayout; }
+            set { this.suppressLayout = value; }
+        }
+
+        public bool SuppressLocalization
+        {
+            get { return this.suppressLocalization; }
+            set { this.suppressLocalization = value; }
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly")]
+        public bool SuppressMsiAssemblyTableProcessing
+        {
+            get { return this.suppressMsiAssemblyTableProcessing; }
+            set { this.suppressMsiAssemblyTableProcessing = value; }
+        }
+
+        public bool SuppressPdbOutput
+        {
+            get { return this.suppressPdbOutput; }
+            set { this.suppressPdbOutput = value; }
+        }
+
+        public bool SuppressSchemaValidation
+        {
+            get { return this.suppressSchemaValidation; }
+            set { this.suppressSchemaValidation = value; }
+        }
+
+        public bool SuppressValidation
+        {
+            get { return this.suppressValidation; }
+            set { this.suppressValidation = value; }
+        }
+
+        public bool SuppressTagSectionIdAttributeOnTuples
+        {
+            get { return this.suppressTagSectionIdAttributeOnTuples; }
+            set { this.suppressTagSectionIdAttributeOnTuples = value; }
+        }
+
+        [Output]
+        public ITaskItem UnreferencedSymbolsFile
+        {
+            get { return this.unreferencedSymbolsFile; }
+            set { this.unreferencedSymbolsFile = value; }
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly")]
+        public ITaskItem WixProjectFile
+        {
+            get { return this.wixProjectFile; }
+            set { this.wixProjectFile = value; }
+        }
+
+        [SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly")]
+        public string[] WixVariables
+        {
+            get { return this.wixVariables; }
+            set { this.wixVariables = value; }
+        }
+
+        public string ExtensionDirectory
+        {
+            get { return this.extensionDirectory; }
+            set { this.extensionDirectory = value; }
+        }
+
+        public string[] ReferencePaths
+        {
+            get { return this.referencePaths; }
+            set { this.referencePaths = value; }
+        }
+
+        /// <summary>
+        /// Get the name of the executable.
+        /// </summary>
+        /// <remarks>The ToolName is used with the ToolPath to get the location of light.exe.</remarks>
+        /// <value>The name of the executable.</value>
+        protected override string ToolName
+        {
+            get { return LightToolName; }
+        }
+
+        /// <summary>
+        /// Get the path to the executable. 
+        /// </summary>
+        /// <remarks>GetFullPathToTool is only called when the ToolPath property is not set (see the ToolName remarks above).</remarks>
+        /// <returns>The full path to the executable or simply light.exe if it's expected to be in the system path.</returns>
+        protected override string GenerateFullPathToTool()
+        {
+            // If there's not a ToolPath specified, it has to be in the system path.
+            if (String.IsNullOrEmpty(this.ToolPath))
+            {
+                return LightToolName;
+            }
+
+            return Path.Combine(Path.GetFullPath(this.ToolPath), LightToolName);
+        }
+
+        /// <summary>
+        /// Builds a command line from options in this task.
+        /// </summary>
+        protected override void BuildCommandLine(WixCommandLineBuilder commandLineBuilder)
+        {
+            // Always put the output first so it is easy to find in the log.
+            commandLineBuilder.AppendSwitchIfNotNull("-out ", this.OutputFile);
+            commandLineBuilder.AppendSwitchIfNotNull("-pdbout ", this.PdbOutputFile);
+
+            base.BuildCommandLine(commandLineBuilder);
+
+            commandLineBuilder.AppendIfTrue("-ai", this.AllowIdenticalRows);
+            commandLineBuilder.AppendIfTrue("-au", this.AllowUnresolvedReferences);
+            commandLineBuilder.AppendArrayIfNotNull("-b ", this.baseInputPaths);
+
+            if (null != this.BindInputPaths)
+            {
+                Queue<String> formattedBindInputPaths = new Queue<String>();
+                foreach (ITaskItem item in this.BindInputPaths)
+                {
+                    String formattedPath = string.Empty;
+                    String bindName = item.GetMetadata("BindName");
+                    if (!String.IsNullOrEmpty(bindName))
+                    {
+                        formattedPath = String.Concat(bindName, "=", item.GetMetadata("FullPath"));
+                    }
+                    else
+                    {
+                        formattedPath = item.GetMetadata("FullPath");
+                    }
+                    formattedBindInputPaths.Enqueue(formattedPath);
+                }
+                commandLineBuilder.AppendArrayIfNotNull("-b ", formattedBindInputPaths.ToArray());
+            }
+
+            commandLineBuilder.AppendIfTrue("-bcgg", this.BackwardsCompatibleGuidGeneration);
+            commandLineBuilder.AppendIfTrue("-bf", this.BindFiles);
+            commandLineBuilder.AppendSwitchIfNotNull("-cc ", this.CabinetCachePath);
+            commandLineBuilder.AppendIfSpecified("-ct ", this.CabinetCreationThreadCount);
+            commandLineBuilder.AppendSwitchIfNotNull("-cub ", this.AdditionalCub);
+            commandLineBuilder.AppendSwitchIfNotNull("-cultures:", this.Cultures);
+            commandLineBuilder.AppendSwitchIfNotNull("-binder ", this.CustomBinder);
+            commandLineBuilder.AppendArrayIfNotNull("-d", this.WixVariables);
+            commandLineBuilder.AppendSwitchIfNotNull("-dcl:", this.DefaultCompressionLevel);
+            commandLineBuilder.AppendIfTrue("-dut", this.DropUnrealTables);
+            commandLineBuilder.AppendIfTrue("-eav", this.ExactAssemblyVersions);
+            commandLineBuilder.AppendExtensions(this.Extensions, this.ExtensionDirectory, this.referencePaths);
+            commandLineBuilder.AppendArrayIfNotNull("-ice:", this.Ices);
+            commandLineBuilder.AppendArrayIfNotNull("-loc ", this.LocalizationFiles);
+            commandLineBuilder.AppendIfTrue("-notidy", this.LeaveTemporaryFiles);
+            commandLineBuilder.AppendIfTrue("-pedantic", this.Pedantic);
+            commandLineBuilder.AppendIfTrue("-reusecab", this.ReuseCabinetCache);
+            commandLineBuilder.AppendIfTrue("-sa", this.SuppressAssemblies);
+            commandLineBuilder.AppendIfTrue("-sacl", this.SuppressAclReset);
+            commandLineBuilder.AppendIfTrue("-sadmin", this.SuppressDefaultAdminSequenceActions);
+            commandLineBuilder.AppendIfTrue("-sadv", this.SuppressDefaultAdvSequenceActions);
+            commandLineBuilder.AppendArrayIfNotNull("-sice:", this.SuppressIces);
+            commandLineBuilder.AppendIfTrue("-sma", this.SuppressMsiAssemblyTableProcessing);
+            commandLineBuilder.AppendIfTrue("-sf", this.SuppressFiles);
+            commandLineBuilder.AppendIfTrue("-sh", this.SuppressFileHashAndInfo);
+            commandLineBuilder.AppendIfTrue("-sl", this.SuppressLayout);
+            commandLineBuilder.AppendIfTrue("-sloc", this.SuppressLocalization);
+            commandLineBuilder.AppendIfTrue("-spdb", this.SuppressPdbOutput);
+            commandLineBuilder.AppendIfTrue("-ss", this.SuppressSchemaValidation);
+            commandLineBuilder.AppendIfTrue("-sts", this.SuppressTagSectionIdAttributeOnTuples);
+            commandLineBuilder.AppendIfTrue("-sui", this.SuppressDefaultUISequenceActions);
+            commandLineBuilder.AppendIfTrue("-sv", this.SuppressIntermediateFileVersionMatching);
+            commandLineBuilder.AppendIfTrue("-sval", this.SuppressValidation);
+            commandLineBuilder.AppendSwitchIfNotNull("-usf ", this.UnreferencedSymbolsFile);
+            commandLineBuilder.AppendIfTrue("-xo", this.OutputAsXml);
+            commandLineBuilder.AppendSwitchIfNotNull("-contentsfile ", this.BindContentsFile);
+            commandLineBuilder.AppendSwitchIfNotNull("-outputsfile ", this.BindOutputsFile);
+            commandLineBuilder.AppendSwitchIfNotNull("-builtoutputsfile ", this.BindBuiltOutputsFile);
+            commandLineBuilder.AppendSwitchIfNotNull("-wixprojectfile ", this.WixProjectFile);
+            commandLineBuilder.AppendTextIfNotNull(this.AdditionalOptions);
+
+            List<string> objectFilePaths = AdjustFilePaths(this.objectFiles, this.ReferencePaths);
+            commandLineBuilder.AppendFileNamesIfNotNull(objectFilePaths.ToArray(), " ");
+        }
+    }
+}
diff --git a/src/WixToolset.BuildTasks/Lit.cs b/src/WixToolset.BuildTasks/Lit.cs
new file mode 100644
index 00000000..1df964ae
--- /dev/null
+++ b/src/WixToolset.BuildTasks/Lit.cs
@@ -0,0 +1,178 @@
+// 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.BuildTasks
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Globalization;
+    using System.IO;
+    using System.Text;
+
+    using Microsoft.Build.Framework;
+    using Microsoft.Build.Utilities;
+
+    /// <summary>
+    /// An MSBuild task to run the WiX lib tool.
+    /// </summary>
+    public sealed class Lit : WixToolTask
+    {
+        private const string LitToolName = "lit.exe";
+
+        private string[] baseInputPaths;
+        private ITaskItem[] bindInputPaths;
+        private bool bindFiles;
+        private ITaskItem[] extensions;
+        private ITaskItem[] localizationFiles;
+        private ITaskItem[] objectFiles;
+        private ITaskItem outputFile;
+        private bool pedantic;
+        private bool suppressIntermediateFileVersionMatching;
+        private bool suppressSchemaValidation;
+        private string extensionDirectory;
+        private string[] referencePaths;
+
+        // TODO: remove this property entirely in v4.0
+        [Obsolete("Use BindInputPaths instead of BaseInputPaths.")]
+        public string[] BaseInputPaths
+        {
+            get { return this.baseInputPaths; }
+            set { this.baseInputPaths = value; }
+        }
+
+        public ITaskItem[] BindInputPaths
+        {
+            get { return this.bindInputPaths; }
+            set { this.bindInputPaths = value; }
+        }
+
+        public bool BindFiles
+        {
+            get { return this.bindFiles; }
+            set { this.bindFiles = value; }
+        }
+
+        public ITaskItem[] Extensions
+        {
+            get { return this.extensions; }
+            set { this.extensions = value; }
+        }
+
+        public ITaskItem[] LocalizationFiles
+        {
+            get { return this.localizationFiles; }
+            set { this.localizationFiles = value; }
+        }
+
+        [Required]
+        public ITaskItem[] ObjectFiles
+        {
+            get { return this.objectFiles; }
+            set { this.objectFiles = value; }
+        }
+
+        [Required]
+        [Output]
+        public ITaskItem OutputFile
+        {
+            get { return this.outputFile; }
+            set { this.outputFile = value; }
+        }
+
+        public bool Pedantic
+        {
+            get { return this.pedantic; }
+            set { this.pedantic = value; }
+        }
+
+        public bool SuppressIntermediateFileVersionMatching
+        {
+            get { return this.suppressIntermediateFileVersionMatching; }
+            set { this.suppressIntermediateFileVersionMatching = value; }
+        }
+
+        public bool SuppressSchemaValidation
+        {
+            get { return this.suppressSchemaValidation; }
+            set { this.suppressSchemaValidation = value; }
+        }
+
+        public string ExtensionDirectory
+        {
+            get { return this.extensionDirectory; }
+            set { this.extensionDirectory = value; }
+        }
+
+        public string[] ReferencePaths
+        {
+            get { return this.referencePaths; }
+            set { this.referencePaths = value; }
+        }
+
+        /// <summary>
+        /// Get the name of the executable.
+        /// </summary>
+        /// <remarks>The ToolName is used with the ToolPath to get the location of lit.exe</remarks>
+        /// <value>The name of the executable.</value>
+        protected override string ToolName
+        {
+            get { return LitToolName; }
+        }
+
+        /// <summary>
+        /// Get the path to the executable. 
+        /// </summary>
+        /// <remarks>GetFullPathToTool is only called when the ToolPath property is not set (see the ToolName remarks above).</remarks>
+        /// <returns>The full path to the executable or simply lit.exe if it's expected to be in the system path.</returns>
+        protected override string GenerateFullPathToTool()
+        {
+            // If there's not a ToolPath specified, it has to be in the system path.
+            if (String.IsNullOrEmpty(this.ToolPath))
+            {
+                return LitToolName;
+            }
+
+            return Path.Combine(Path.GetFullPath(this.ToolPath), LitToolName);
+        }
+
+        /// <summary>
+        /// Builds a command line from options in this task.
+        /// </summary>
+        protected override void BuildCommandLine(WixCommandLineBuilder commandLineBuilder)
+        {
+            base.BuildCommandLine(commandLineBuilder);
+
+            commandLineBuilder.AppendSwitchIfNotNull("-out ", this.OutputFile);
+            commandLineBuilder.AppendArrayIfNotNull("-b ", this.baseInputPaths);
+            if (null != this.BindInputPaths)
+            {
+                Queue<String> formattedBindInputPaths = new Queue<String>();
+                foreach (ITaskItem item in this.BindInputPaths)
+                {
+                    String formattedPath = string.Empty;
+                    String bindName = item.GetMetadata("BindName");
+                    if (!String.IsNullOrEmpty(item.GetMetadata("BindName")))
+                    {
+                        formattedPath = String.Concat(bindName, "=", item.GetMetadata("FullPath"));
+                    }
+                    else
+                    {
+                        formattedPath = item.GetMetadata("FullPath");
+                    }
+                    formattedBindInputPaths.Enqueue(formattedPath);
+                }
+                commandLineBuilder.AppendArrayIfNotNull("-b ", formattedBindInputPaths.ToArray());
+            }
+            commandLineBuilder.AppendIfTrue("-bf", this.BindFiles);
+            commandLineBuilder.AppendExtensions(this.extensions, this.ExtensionDirectory, this.referencePaths);
+            commandLineBuilder.AppendArrayIfNotNull("-loc ", this.LocalizationFiles);
+            commandLineBuilder.AppendIfTrue("-pedantic", this.Pedantic);
+            commandLineBuilder.AppendIfTrue("-ss", this.SuppressSchemaValidation);
+            commandLineBuilder.AppendIfTrue("-sv", this.SuppressIntermediateFileVersionMatching);
+            commandLineBuilder.AppendTextIfNotNull(this.AdditionalOptions);
+
+            List<string> objectFilePaths = AdjustFilePaths(this.objectFiles, this.ReferencePaths);
+            commandLineBuilder.AppendFileNamesIfNotNull(objectFilePaths.ToArray(), " ");
+        }
+    }
+}
diff --git a/src/WixToolset.BuildTasks/Pyro.cs b/src/WixToolset.BuildTasks/Pyro.cs
new file mode 100644
index 00000000..f6b069da
--- /dev/null
+++ b/src/WixToolset.BuildTasks/Pyro.cs
@@ -0,0 +1,140 @@
+// 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.BuildTasks
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using Microsoft.Build.Framework;
+
+    /// <summary>
+    /// An MSBuild task to run the WiX patch builder.
+    /// </summary>
+    public sealed class Pyro : WixToolTask
+    {
+        private const string PyroToolName = "pyro.exe";
+
+        public bool BinaryDeltaPatch { get; set; }
+        public string CabinetCachePath { get; set; }
+        public string ExtensionDirectory { get; set; }
+        public ITaskItem[] Extensions { get; set; }
+        public bool LeaveTemporaryFiles { get; set; }
+        public string[] ReferencePaths { get; set; }
+        public bool ReuseCabinetCache { get; set; }
+        public bool SuppressAssemblies { get; set; }
+        public bool SuppressFiles { get; set; }
+        public bool SuppressFileHashAndInfo { get; set; }
+        public bool SuppressPdbOutput { get; set; }
+
+        [Required]
+        public string DefaultBaselineId { get; set; }
+
+        public ITaskItem[] BindInputPathsForTarget { get; set; }
+        public ITaskItem[] BindInputPathsForUpdated { get; set; }
+
+        [Required]
+        public ITaskItem InputFile { get; set; }
+
+        [Required]
+        [Output]
+        public ITaskItem OutputFile { get; set; }
+
+        [Output]
+        public ITaskItem PdbOutputFile { get; set; }
+
+        [Required]
+        public ITaskItem[] Transforms { get; set; }
+
+        /// <summary>
+        /// Get the name of the executable.
+        /// </summary>
+        /// <remarks>The ToolName is used with the ToolPath to get the location of pyro.exe.</remarks>
+        /// <value>The name of the executable.</value>
+        protected override string ToolName
+        {
+            get { return PyroToolName; }
+        }
+
+        /// <summary>
+        /// Get the path to the executable. 
+        /// </summary>
+        /// <remarks>GetFullPathToTool is only called when the ToolPath property is not set (see the ToolName remarks above).</remarks>
+        /// <returns>The full path to the executable or simply torch.exe if it's expected to be in the system path.</returns>
+        protected override string GenerateFullPathToTool()
+        {
+            // If there's not a ToolPath specified, it has to be in the system path.
+            if (String.IsNullOrEmpty(this.ToolPath))
+            {
+                return PyroToolName;
+            }
+
+            return Path.Combine(Path.GetFullPath(this.ToolPath), PyroToolName);
+        }
+
+        /// <summary>
+        /// Builds a command line for bind-input paths (-bt and -bu switches).
+        /// </summary>
+        private void AppendBindInputPaths(WixCommandLineBuilder commandLineBuilder, IEnumerable<ITaskItem> bindInputPaths, string switchName)
+        {
+            if (null != bindInputPaths)
+            {
+                Queue<String> formattedBindInputPaths = new Queue<String>();
+                foreach (ITaskItem item in bindInputPaths)
+                {
+                    String formattedPath = string.Empty;
+                    String bindName = item.GetMetadata("BindName");
+                    if (!String.IsNullOrEmpty(bindName))
+                    {
+                        formattedPath = String.Concat(bindName, "=", item.GetMetadata("FullPath"));
+                    }
+                    else
+                    {
+                        formattedPath = item.GetMetadata("FullPath");
+                    }
+                    formattedBindInputPaths.Enqueue(formattedPath);
+                }
+
+                commandLineBuilder.AppendArrayIfNotNull(switchName, formattedBindInputPaths.ToArray());
+            }
+        }
+
+        /// <summary>
+        /// Builds a command line from options in this task.
+        /// </summary>
+        protected override void BuildCommandLine(WixCommandLineBuilder commandLineBuilder)
+        {
+            // Always put the output first so it is easy to find in the log.
+            commandLineBuilder.AppendSwitchIfNotNull("-out ", this.OutputFile);
+            commandLineBuilder.AppendSwitchIfNotNull("-pdbout ", this.PdbOutputFile);
+
+            base.BuildCommandLine(commandLineBuilder);
+
+            this.AppendBindInputPaths(commandLineBuilder, this.BindInputPathsForTarget, "-bt ");
+            this.AppendBindInputPaths(commandLineBuilder, this.BindInputPathsForUpdated, "-bu ");
+
+            commandLineBuilder.AppendFileNameIfNotNull(this.InputFile);
+            commandLineBuilder.AppendSwitchIfNotNull("-cc ", this.CabinetCachePath);
+            commandLineBuilder.AppendIfTrue("-delta", this.BinaryDeltaPatch);
+            commandLineBuilder.AppendExtensions(this.Extensions, this.ExtensionDirectory, this.ReferencePaths);
+            commandLineBuilder.AppendIfTrue("-notidy", this.LeaveTemporaryFiles);
+            commandLineBuilder.AppendIfTrue("-reusecab", this.ReuseCabinetCache);
+            commandLineBuilder.AppendIfTrue("-sa", this.SuppressAssemblies);
+            commandLineBuilder.AppendIfTrue("-sf", this.SuppressFiles);
+            commandLineBuilder.AppendIfTrue("-sh", this.SuppressFileHashAndInfo);
+            commandLineBuilder.AppendIfTrue("-spdb", this.SuppressPdbOutput);
+            foreach (ITaskItem transform in this.Transforms)
+            {
+                string transformPath = transform.ItemSpec;
+                string baselineId = transform.GetMetadata("OverrideBaselineId");
+                if (String.IsNullOrEmpty(baselineId))
+                {
+                    baselineId = this.DefaultBaselineId;
+                }
+
+                commandLineBuilder.AppendTextIfNotNull(String.Format("-t {0} {1}", baselineId, transformPath));
+            }
+
+            commandLineBuilder.AppendTextIfNotNull(this.AdditionalOptions);
+        }
+    }
+}
diff --git a/src/WixToolset.BuildTasks/RefreshBundleGeneratedFile.cs b/src/WixToolset.BuildTasks/RefreshBundleGeneratedFile.cs
new file mode 100644
index 00000000..5445e0cd
--- /dev/null
+++ b/src/WixToolset.BuildTasks/RefreshBundleGeneratedFile.cs
@@ -0,0 +1,132 @@
+// 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.BuildTasks
+{
+    using System;
+    using System.Collections;
+    using System.Globalization;
+    using System.IO;
+    using System.Text.RegularExpressions;
+    using System.Xml;
+    using Microsoft.Build.Framework;
+    using Microsoft.Build.Utilities;
+
+    /// <summary>
+    /// This task refreshes the generated file for bundle projects.
+    /// </summary>
+    public class RefreshBundleGeneratedFile : Task
+    {
+        private static readonly Regex AddPrefix = new Regex(@"^[^a-zA-Z_]", RegexOptions.Compiled);
+        private static readonly Regex IllegalIdentifierCharacters = new Regex(@"[^A-Za-z0-9_\.]|\.{2,}", RegexOptions.Compiled); // non 'words' and assorted valid characters
+
+        private ITaskItem[] generatedFiles;
+        private ITaskItem[] projectReferencePaths;
+
+        /// <summary>
+        /// The list of files to generate.
+        /// </summary>
+        [Required]
+        public ITaskItem[] GeneratedFiles
+        {
+            get { return this.generatedFiles; }
+            set { this.generatedFiles = value; }
+        }
+
+        /// <summary>
+        /// All the project references in the project.
+        /// </summary>
+        [Required]
+        public ITaskItem[] ProjectReferencePaths
+        {
+            get { return this.projectReferencePaths; }
+            set { this.projectReferencePaths = value; }
+        }
+
+        /// <summary>
+        /// Gets a complete list of external cabs referenced by the given installer database file.
+        /// </summary>
+        /// <returns>True upon completion of the task execution.</returns>
+        public override bool Execute()
+        {
+            ArrayList payloadGroupRefs = new ArrayList();
+            ArrayList packageGroupRefs = new ArrayList();
+            for (int i = 0; i < this.ProjectReferencePaths.Length; i++)
+            {
+                ITaskItem item = this.ProjectReferencePaths[i];
+
+                if (!String.IsNullOrEmpty(item.GetMetadata(Common.DoNotHarvest)))
+                {
+                    continue;
+                }
+
+                string projectPath = CreateProjectReferenceDefineConstants.GetProjectPath(this.ProjectReferencePaths, i);
+                string projectName = Path.GetFileNameWithoutExtension(projectPath);
+                string referenceName = Common.GetIdentifierFromName(CreateProjectReferenceDefineConstants.GetReferenceName(item, projectName));
+
+                string[] pogs = item.GetMetadata("RefProjectOutputGroups").Split(';');
+                foreach (string pog in pogs)
+                {
+                    if (!String.IsNullOrEmpty(pog))
+                    {
+                        // TODO: Add payload group references and package group references once heat is generating them
+                        ////payloadGroupRefs.Add(String.Format(CultureInfo.InvariantCulture, "{0}.{1}", referenceName, pog));
+                        packageGroupRefs.Add(String.Format(CultureInfo.InvariantCulture, "{0}.{1}", referenceName, pog));
+                    }
+                }
+            }
+
+            XmlDocument doc = new XmlDocument();
+
+            XmlProcessingInstruction head = doc.CreateProcessingInstruction("xml", "version='1.0' encoding='UTF-8'");
+            doc.AppendChild(head);
+
+            XmlElement rootElement = doc.CreateElement("Wix");
+            rootElement.SetAttribute("xmlns", "http://wixtoolset.org/schemas/v4/wxs");
+            doc.AppendChild(rootElement);
+
+            XmlElement fragment = doc.CreateElement("Fragment");
+            rootElement.AppendChild(fragment);
+
+            XmlElement payloadGroup = doc.CreateElement("PayloadGroup");
+            payloadGroup.SetAttribute("Id", "Bundle.Generated.Payloads");
+            fragment.AppendChild(payloadGroup);
+
+            XmlElement packageGroup = doc.CreateElement("PackageGroup");
+            packageGroup.SetAttribute("Id", "Bundle.Generated.Packages");
+            fragment.AppendChild(packageGroup);
+
+            foreach (string payloadGroupRef in payloadGroupRefs)
+            {
+                XmlElement payloadGroupRefElement = doc.CreateElement("PayloadGroupRef");
+                payloadGroupRefElement.SetAttribute("Id", payloadGroupRef);
+                payloadGroup.AppendChild(payloadGroupRefElement);
+            }
+
+            foreach (string packageGroupRef in packageGroupRefs)
+            {
+                XmlElement packageGroupRefElement = doc.CreateElement("PackageGroupRef");
+                packageGroupRefElement.SetAttribute("Id", packageGroupRef);
+                packageGroup.AppendChild(packageGroupRefElement);
+            }
+
+            foreach (ITaskItem item in this.GeneratedFiles)
+            {
+                string fullPath = item.GetMetadata("FullPath");
+
+                payloadGroup.SetAttribute("Id", Path.GetFileNameWithoutExtension(fullPath) + ".Payloads");
+                packageGroup.SetAttribute("Id", Path.GetFileNameWithoutExtension(fullPath) + ".Packages");
+                try
+                {
+                    doc.Save(fullPath);
+                }
+                catch (Exception e)
+                {
+                    // e.Message will be something like: "Access to the path 'fullPath' is denied."
+                    this.Log.LogMessage(MessageImportance.High, "Unable to save generated file to '{0}'. {1}", fullPath, e.Message);
+                }
+            }
+
+            return true;
+        }
+    }
+}
diff --git a/src/WixToolset.BuildTasks/RefreshGeneratedFile.cs b/src/WixToolset.BuildTasks/RefreshGeneratedFile.cs
new file mode 100644
index 00000000..fdfc4774
--- /dev/null
+++ b/src/WixToolset.BuildTasks/RefreshGeneratedFile.cs
@@ -0,0 +1,118 @@
+// 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.BuildTasks
+{
+    using System;
+    using System.Collections;
+    using System.Globalization;
+    using System.IO;
+    using System.Text.RegularExpressions;
+    using System.Xml;
+    using Microsoft.Build.Framework;
+    using Microsoft.Build.Utilities;
+
+    /// <summary>
+    /// This task refreshes the generated file that contains ComponentGroupRefs
+    /// to harvested output.
+    /// </summary>
+    public class RefreshGeneratedFile : Task
+    {
+        private static readonly Regex AddPrefix = new Regex(@"^[^a-zA-Z_]", RegexOptions.Compiled);
+        private static readonly Regex IllegalIdentifierCharacters = new Regex(@"[^A-Za-z0-9_\.]|\.{2,}", RegexOptions.Compiled); // non 'words' and assorted valid characters
+
+        private ITaskItem[] generatedFiles;
+        private ITaskItem[] projectReferencePaths;
+
+        /// <summary>
+        /// The list of files to generate.
+        /// </summary>
+        [Required]
+        public ITaskItem[] GeneratedFiles
+        {
+            get { return this.generatedFiles; }
+            set { this.generatedFiles = value; }
+        }
+
+        /// <summary>
+        /// All the project references in the project.
+        /// </summary>
+        [Required]
+        public ITaskItem[] ProjectReferencePaths
+        {
+            get { return this.projectReferencePaths; }
+            set { this.projectReferencePaths = value; }
+        }
+
+        /// <summary>
+        /// Gets a complete list of external cabs referenced by the given installer database file.
+        /// </summary>
+        /// <returns>True upon completion of the task execution.</returns>
+        public override bool Execute()
+        {
+            ArrayList componentGroupRefs = new ArrayList();
+            for (int i = 0; i < this.ProjectReferencePaths.Length; i++)
+            {
+                ITaskItem item = this.ProjectReferencePaths[i];
+
+                if (!String.IsNullOrEmpty(item.GetMetadata(Common.DoNotHarvest)))
+                {
+                    continue;
+                }
+
+                string projectPath = CreateProjectReferenceDefineConstants.GetProjectPath(this.ProjectReferencePaths, i);
+                string projectName = Path.GetFileNameWithoutExtension(projectPath);
+                string referenceName = Common.GetIdentifierFromName(CreateProjectReferenceDefineConstants.GetReferenceName(item, projectName));
+
+                string[] pogs = item.GetMetadata("RefProjectOutputGroups").Split(';');
+                foreach (string pog in pogs)
+                {
+                    if (!String.IsNullOrEmpty(pog))
+                    {
+                        componentGroupRefs.Add(String.Format(CultureInfo.InvariantCulture, "{0}.{1}", referenceName, pog));
+                    }
+                }
+            }
+
+            XmlDocument doc = new XmlDocument();
+
+            XmlProcessingInstruction head = doc.CreateProcessingInstruction("xml", "version='1.0' encoding='UTF-8'");
+            doc.AppendChild(head);
+
+            XmlElement rootElement = doc.CreateElement("Wix");
+            rootElement.SetAttribute("xmlns", "http://wixtoolset.org/schemas/v4/wxs");
+            doc.AppendChild(rootElement);
+
+            XmlElement fragment = doc.CreateElement("Fragment");
+            rootElement.AppendChild(fragment);
+
+            XmlElement componentGroup = doc.CreateElement("ComponentGroup");
+            componentGroup.SetAttribute("Id", "Product.Generated");
+            fragment.AppendChild(componentGroup);
+
+            foreach (string componentGroupRef in componentGroupRefs)
+            {
+                XmlElement componentGroupRefElement = doc.CreateElement("ComponentGroupRef");
+                componentGroupRefElement.SetAttribute("Id", componentGroupRef);
+                componentGroup.AppendChild(componentGroupRefElement);
+            }
+
+            foreach (ITaskItem item in this.GeneratedFiles)
+            {
+                string fullPath = item.GetMetadata("FullPath");
+
+                componentGroup.SetAttribute("Id", Path.GetFileNameWithoutExtension(fullPath));
+                try
+                {
+                    doc.Save(fullPath);
+                }
+                catch (Exception e)
+                {
+                    // e.Message will be something like: "Access to the path 'fullPath' is denied."
+                    this.Log.LogMessage(MessageImportance.High, "Unable to save generated file to '{0}'. {1}", fullPath, e.Message);
+                }
+            }
+
+            return true;
+        }
+    }
+}
diff --git a/src/WixToolset.BuildTasks/ReplaceString.cs b/src/WixToolset.BuildTasks/ReplaceString.cs
new file mode 100644
index 00000000..e5041923
--- /dev/null
+++ b/src/WixToolset.BuildTasks/ReplaceString.cs
@@ -0,0 +1,54 @@
+// 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.BuildTasks
+{
+    using System;
+    using Microsoft.Build.Framework;
+    using Microsoft.Build.Utilities;
+
+    /// <summary>
+    /// Replaces occurances of OldValues with NewValues in String.
+    /// </summary>
+    public class ReplaceString : Task
+    {
+        /// <summary>
+        /// Text to operate on.
+        /// </summary>
+        [Output]
+        [Required]
+        public string Text { get; set; }
+
+        /// <summary>
+        /// List of old values to replace.
+        /// </summary>
+        [Required]
+        public string OldValue { get; set; }
+
+        /// <summary>
+        /// List of new values to replace old values with.  If not specified, occurances of OldValue will be removed.
+        /// </summary>
+        public string NewValue { get; set; }
+
+        /// <summary>
+        /// Does the string replacement.
+        /// </summary>
+        /// <returns></returns>
+        public override bool Execute()
+        {
+            if (String.IsNullOrEmpty(this.Text))
+            {
+                return true;
+            }
+
+            if (String.IsNullOrEmpty(this.OldValue))
+            {
+                Log.LogError("OldValue must be specified");
+                return false;
+            }
+
+            this.Text = this.Text.Replace(this.OldValue, this.NewValue);
+
+            return true;
+        }
+    }
+}
diff --git a/src/WixToolset.BuildTasks/ResolveWixReferences.cs b/src/WixToolset.BuildTasks/ResolveWixReferences.cs
new file mode 100644
index 00000000..9b8cfe6f
--- /dev/null
+++ b/src/WixToolset.BuildTasks/ResolveWixReferences.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.BuildTasks
+{
+    using System;
+    using System.Collections.Generic;
+    using Microsoft.Build.Utilities;
+    using Microsoft.Build.Framework;
+    using System.IO;
+
+    /// <summary>
+    /// This task searches for paths to references using the order specified in SearchPaths.
+    /// </summary>
+    public class ResolveWixReferences : Task
+    {
+        /// <summary>
+        /// Token value used in SearchPaths to indicate that the item's HintPath metadata should
+        /// be searched as a full file path to resolve the reference.  
+        /// Must match wix.targets, case sensitive.
+        /// </summary>
+        private const string HintPathToken = "{HintPathFromItem}";
+
+        /// <summary>
+        /// Token value used in SearchPaths to indicate that the item's Identity should
+        /// be searched as a full file path to resolve the reference.  
+        /// Must match wix.targets, case sensitive.
+        /// </summary>
+        private const string RawFileNameToken = "{RawFileName}";
+
+        /// <summary>
+        /// The list of references to resolve.
+        /// </summary>
+        [Required]
+        public ITaskItem[] WixReferences
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// The directories or special locations that are searched to find the files 
+        /// on disk that represent the references. The order in which the search paths are listed 
+        /// is important. For each reference, the list of paths is searched from left to right. 
+        /// When a file that represents the reference is found, that search stops and the search 
+        /// for the next reference starts. 
+        /// 
+        /// This parameter accepts the following types of values: 
+        ///     A directory path. 
+        ///     {HintPathFromItem}: Specifies that the task will examine the HintPath metadata 
+        ///                         of the base item. 
+        ///     TODO : {CandidateAssemblyFiles}: Specifies that the task will examine the files 
+        ///                                      passed in through the CandidateAssemblyFiles parameter. 
+        ///     TODO : {Registry:_AssemblyFoldersBase_, _RuntimeVersion_, _AssemblyFoldersSuffix_}: 
+        ///     TODO : {AssemblyFolders}: Specifies the task will use the Visual Studio.NET 2003 
+        ///                               finding-assemblies-from-registry scheme. 
+        ///     TODO : {GAC}: Specifies the task will search in the GAC. 
+        ///     {RawFileName}: Specifies the task will consider the Include value of the item to be 
+        ///                    an exact path and file name. 
+        /// </summary>
+        public string[] SearchPaths
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// The filename extension(s) to be checked when searching.
+        /// </summary>
+        public string[] SearchFilenameExtensions
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Output items that contain the same metadata as input references and have been resolved to full paths.
+        /// </summary>
+        [Output]
+        public ITaskItem[] ResolvedWixReferences
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// Resolves reference paths by searching for referenced items using the specified SearchPaths.
+        /// </summary>
+        /// <returns>True on success, or throws an exception on failure.</returns>
+        public override bool Execute()
+        {
+            List<ITaskItem> resolvedReferences = new List<ITaskItem>();
+
+            foreach (ITaskItem reference in this.WixReferences)
+            {
+                ITaskItem resolvedReference = ResolveWixReferences.ResolveReference(reference, this.SearchPaths, this.SearchFilenameExtensions, this.Log);
+
+                this.Log.LogMessage(MessageImportance.Low, "Resolved path {0}", resolvedReference.ItemSpec);
+                resolvedReferences.Add(resolvedReference);
+            }
+
+            this.ResolvedWixReferences = resolvedReferences.ToArray();
+            return true;
+        }
+
+        /// <summary>
+        /// Resolves a single reference item by searcheing for referenced items using the specified SearchPaths.
+        /// This method is made public so the resolution logic can be reused by other tasks.
+        /// </summary>
+        /// <param name="reference">The referenced item.</param>
+        /// <param name="searchPaths">The paths to search.</param>
+        /// <param name="searchFilenameExtensions">Filename extensions to check.</param>
+        /// <param name="log">Logging helper.</param>
+        /// <returns>The resolved reference item, or the original reference if it could not be resolved.</returns>
+        public static ITaskItem ResolveReference(ITaskItem reference, string[] searchPaths, string[] searchFilenameExtensions, TaskLoggingHelper log)
+        {
+            if (reference == null)
+            {
+                throw new ArgumentNullException("reference");
+            }
+
+            if (searchPaths == null)
+            {
+                // Nothing to search, so just return the original reference item.
+                return reference;
+            }
+
+            if (searchFilenameExtensions == null)
+            {
+                searchFilenameExtensions = new string[] { };
+            }
+
+            // Copy all the metadata from the source
+            TaskItem resolvedReference = new TaskItem(reference);
+            log.LogMessage(MessageImportance.Low, "WixReference: {0}", reference.ItemSpec);
+
+            // Now find the resolved path based on our order of precedence
+            foreach (string searchPath in searchPaths)
+            {
+                log.LogMessage(MessageImportance.Low, "Trying {0}", searchPath);
+                if (searchPath.Equals(HintPathToken, StringComparison.Ordinal))
+                {
+                    string path = reference.GetMetadata("HintPath");
+                    log.LogMessage(MessageImportance.Low, "Trying path {0}", path);
+                    if (File.Exists(path))
+                    {
+                        resolvedReference.ItemSpec = path;
+                        break;
+                    }
+                }
+                else if (searchPath.Equals(RawFileNameToken, StringComparison.Ordinal))
+                {
+                    log.LogMessage(MessageImportance.Low, "Trying path {0}", resolvedReference.ItemSpec);
+                    if (File.Exists(resolvedReference.ItemSpec))
+                    {
+                        break;
+                    }
+
+                    if (ResolveWixReferences.ResolveFilenameExtensions(resolvedReference,
+                        resolvedReference.ItemSpec, searchFilenameExtensions, log))
+                    {
+                        break;
+                    }
+                }
+                else
+                {
+                    string path = Path.Combine(searchPath, Path.GetFileName(reference.ItemSpec));
+                    log.LogMessage(MessageImportance.Low, "Trying path {0}", path);
+                    if (File.Exists(path))
+                    {
+                        resolvedReference.ItemSpec = path;
+                        break;
+                    }
+
+                    if (ResolveWixReferences.ResolveFilenameExtensions(resolvedReference,
+                        path, searchFilenameExtensions, log))
+                    {
+                        break;
+                    }
+                }
+            }
+
+            // Normalize the item path
+            resolvedReference.ItemSpec = resolvedReference.GetMetadata("FullPath");
+
+            return resolvedReference;
+        }
+
+        /// <summary>
+        /// Helper method for checking filename extensions when resolving references.
+        /// </summary>
+        /// <param name="reference">The reference being resolved.</param>
+        /// <param name="basePath">Full filename path without extension.</param>
+        /// <param name="filenameExtensions">Filename extensions to check.</param>
+        /// <param name="log">Logging helper.</param>
+        /// <returns>True if the item was resolved, else false.</returns>
+        private static bool ResolveFilenameExtensions(ITaskItem reference, string basePath, string[] filenameExtensions, TaskLoggingHelper log)
+        {
+            foreach (string filenameExtension in filenameExtensions)
+            {
+                string path = basePath + filenameExtension;
+                log.LogMessage(MessageImportance.Low, "Trying path {0}", path);
+                if (File.Exists(path))
+                {
+                    reference.ItemSpec = path;
+                    return true;
+                }
+            }
+
+            return false;
+        }
+    }
+}
diff --git a/src/WixToolset.BuildTasks/TaskBase.cs b/src/WixToolset.BuildTasks/TaskBase.cs
new file mode 100644
index 00000000..3d58fc06
--- /dev/null
+++ b/src/WixToolset.BuildTasks/TaskBase.cs
@@ -0,0 +1,65 @@
+// 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.BuildTasks
+{
+    using Microsoft.Build.Utilities;
+
+    public abstract class TaskBase : Task
+    {
+        public string ToolPath { get; set; }
+
+        public string AdditionalOptions { get; set; }
+
+        public bool RunAsSeparateProcess { get; set; }
+
+        /// <summary>
+        /// Gets or sets whether all warnings should be suppressed.
+        /// </summary>
+        public bool SuppressAllWarnings { get; set; }
+
+        /// <summary>
+        /// Gets or sets a list of specific warnings to be suppressed.
+        /// </summary>
+        public string[] SuppressSpecificWarnings { get; set; }
+
+        /// <summary>
+        /// Gets or sets whether all warnings should be treated as errors.
+        /// </summary>
+        public bool TreatWarningsAsErrors { get; set; }
+
+        /// <summary>
+        /// Gets or sets a list of specific warnings to treat as errors.
+        /// </summary>
+        public string[] TreatSpecificWarningsAsErrors { get; set; }
+
+        /// <summary>
+        /// Gets or sets whether to display verbose output.
+        /// </summary>
+        public bool VerboseOutput { get; set; }
+
+        /// <summary>
+        /// Gets or sets whether to display the logo.
+        /// </summary>
+        public bool NoLogo { get; set; }
+
+        public override bool Execute()
+        {
+            try
+            {
+                this.ExecuteCore();
+            }
+            catch (BuildException e)
+            {
+                this.Log.LogErrorFromException(e);
+            }
+            catch (Data.WixException e)
+            {
+                this.Log.LogErrorFromException(e);
+            }
+
+            return !this.Log.HasLoggedErrors;
+        }
+
+        protected abstract void ExecuteCore();
+    }
+}
diff --git a/src/WixToolset.BuildTasks/Torch.cs b/src/WixToolset.BuildTasks/Torch.cs
new file mode 100644
index 00000000..e18ed315
--- /dev/null
+++ b/src/WixToolset.BuildTasks/Torch.cs
@@ -0,0 +1,159 @@
+// 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.BuildTasks
+{
+    using System;
+    using System.Diagnostics;
+    using System.Globalization;
+    using System.IO;
+    using System.Text;
+
+    using Microsoft.Build.Framework;
+    using Microsoft.Build.Utilities;
+
+    /// <summary>
+    /// An MSBuild task to run the WiX transform generator.
+    /// </summary>
+    public sealed class Torch : WixToolTask
+    {
+        private const string TorchToolName = "Torch.exe";
+
+        private bool adminImage;
+        private ITaskItem baselineFile;
+        private string binaryExtractionPath;
+        private bool inputIsXml;
+        private bool leaveTemporaryFiles;
+        private bool outputAsXml;
+        private ITaskItem outputFile;
+        private bool preserveUnmodifiedContent;
+        private string suppressTransformErrorFlags;
+        private string transformValidationFlags;
+        private string transformValidationType;
+        private ITaskItem updateFile;
+
+        public bool AdminImage
+        {
+            get { return this.adminImage; }
+            set { this.adminImage = value; }
+        }
+
+
+        [Required]
+        public ITaskItem BaselineFile
+        {
+            get { return this.baselineFile; }
+            set { this.baselineFile = value; }
+        }
+
+        public string BinaryExtractionPath
+        {
+            get { return this.binaryExtractionPath; }
+            set { this.binaryExtractionPath = value; }
+        }
+
+        public bool LeaveTemporaryFiles
+        {
+            get { return this.leaveTemporaryFiles; }
+            set { this.leaveTemporaryFiles = value; }
+        }
+
+        public bool InputIsXml
+        {
+            get { return this.inputIsXml; }
+            set { this.inputIsXml = value; }
+        }
+
+        public bool OutputAsXml
+        {
+            get { return this.outputAsXml; }
+            set { this.outputAsXml = value; }
+        }
+
+        public bool PreserveUnmodifiedContent
+        {
+            get { return this.preserveUnmodifiedContent; }
+            set { this.preserveUnmodifiedContent = value; }
+        }
+
+        [Required]
+        [Output]
+        public ITaskItem OutputFile
+        {
+            get { return this.outputFile; }
+            set { this.outputFile = value; }
+        }
+
+        public string SuppressTransformErrorFlags
+        {
+            get { return this.suppressTransformErrorFlags; }
+            set { this.suppressTransformErrorFlags = value; }
+        }
+
+        public string TransformValidationType
+        {
+            get { return this.transformValidationType; }
+            set { this.transformValidationType = value; }
+        }
+
+        public string TransformValidationFlags
+        {
+            get { return this.transformValidationFlags; }
+            set { this.transformValidationFlags = value; }
+        }
+
+        [Required]
+        public ITaskItem UpdateFile
+        {
+            get { return this.updateFile; }
+            set { this.updateFile = value; }
+        }
+
+        /// <summary>
+        /// Get the name of the executable.
+        /// </summary>
+        /// <remarks>The ToolName is used with the ToolPath to get the location of torch.exe.</remarks>
+        /// <value>The name of the executable.</value>
+        protected override string ToolName
+        {
+            get { return TorchToolName; }
+        }
+
+        /// <summary>
+        /// Get the path to the executable. 
+        /// </summary>
+        /// <remarks>GetFullPathToTool is only called when the ToolPath property is not set (see the ToolName remarks above).</remarks>
+        /// <returns>The full path to the executable or simply torch.exe if it's expected to be in the system path.</returns>
+        protected override string GenerateFullPathToTool()
+        {
+            // If there's not a ToolPath specified, it has to be in the system path.
+            if (String.IsNullOrEmpty(this.ToolPath))
+            {
+                return TorchToolName;
+            }
+
+            return Path.Combine(Path.GetFullPath(this.ToolPath), TorchToolName);
+        }
+
+        /// <summary>
+        /// Builds a command line from options in this task.
+        /// </summary>
+        protected override void BuildCommandLine(WixCommandLineBuilder commandLineBuilder)
+        {
+            base.BuildCommandLine(commandLineBuilder);
+
+            commandLineBuilder.AppendIfTrue("-notidy", this.LeaveTemporaryFiles);
+            commandLineBuilder.AppendIfTrue("-xo", this.OutputAsXml);
+            commandLineBuilder.AppendIfTrue("-xi", this.InputIsXml);
+            commandLineBuilder.AppendIfTrue("-p", this.PreserveUnmodifiedContent);
+            commandLineBuilder.AppendTextIfNotNull(this.AdditionalOptions);
+            commandLineBuilder.AppendFileNameIfNotNull(this.BaselineFile);
+            commandLineBuilder.AppendFileNameIfNotNull(this.UpdateFile);
+            commandLineBuilder.AppendSwitchIfNotNull("-out ", this.OutputFile);
+            commandLineBuilder.AppendIfTrue("-a", this.adminImage);
+            commandLineBuilder.AppendSwitchIfNotNull("-x ", this.BinaryExtractionPath);
+            commandLineBuilder.AppendSwitchIfNotNull("-serr ", this.SuppressTransformErrorFlags);
+            commandLineBuilder.AppendSwitchIfNotNull("-t ", this.TransformValidationType);
+            commandLineBuilder.AppendSwitchIfNotNull("-val ", this.TransformValidationFlags);
+        }
+    }
+}
diff --git a/src/WixToolset.BuildTasks/WixAssignCulture.cs b/src/WixToolset.BuildTasks/WixAssignCulture.cs
new file mode 100644
index 00000000..7a03dc47
--- /dev/null
+++ b/src/WixToolset.BuildTasks/WixAssignCulture.cs
@@ -0,0 +1,231 @@
+// 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.BuildTasks
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.IO;
+    using System.Xml;
+    using Microsoft.Build.Framework;
+    using Microsoft.Build.Utilities;
+
+    /// <summary>
+    /// This task assigns Culture metadata to files based on the value of the Culture attribute on the
+    /// WixLocalization element inside the file.
+    /// </summary>
+    public class WixAssignCulture : Task
+    {
+        private const string CultureAttributeName = "Culture";
+        private const string OutputFolderMetadataName = "OutputFolder";
+        private const string InvariantCultureIdentifier = "neutral";
+        private const string NullCultureIdentifier = "null";
+
+        /// <summary>
+        /// The list of cultures to build.  Cultures are specified in the following form:
+        ///     primary culture,first fallback culture, second fallback culture;...
+        /// Culture groups are seperated by semi-colons 
+        /// Culture precedence within a culture group is evaluated from left to right where fallback cultures are 
+        /// separated with commas.
+        /// The first (primary) culture in a culture group will be used as the output sub-folder.
+        /// </summary>
+        public string Cultures { get; set; }
+
+        /// <summary>
+        /// The list of files to apply culture information to.
+        /// </summary>
+        [Required]
+        public ITaskItem[] Files
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// The files that had culture information applied
+        /// </summary>
+        [Output]
+        public ITaskItem[] CultureGroups
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// Applies culture information to the files specified by the Files property.
+        /// This task intentionally does not validate that strings are valid Cultures so that we can support
+        /// psuedo-loc.
+        /// </summary>
+        /// <returns>True upon completion of the task execution.</returns>
+        public override bool Execute()
+        {
+            // First, process the culture group list the user specified in the cultures property
+            List<CultureGroup> cultureGroups = new List<CultureGroup>();
+
+            if (!String.IsNullOrEmpty(this.Cultures))
+            {
+                // Get rid of extra quotes
+                this.Cultures = this.Cultures.Trim('\"');
+
+                foreach (string cultureGroupString in this.Cultures.Split(';'))
+                {
+                    if (0 == cultureGroupString.Length)
+                    {
+                        // MSBuild v2.0.50727 cannnot handle "" items
+                        // for the invariant culture we require the neutral keyword
+                        continue;
+                    }
+                    CultureGroup cultureGroup = new CultureGroup(cultureGroupString);
+                    cultureGroups.Add(cultureGroup);
+                }
+            }
+            else
+            {
+                // Only process the EmbeddedResource items if cultures was unspecified
+                foreach (ITaskItem file in this.Files)
+                {
+                    // Ignore non-wxls
+                    if (!String.Equals(file.GetMetadata("Extension"), ".wxl", StringComparison.OrdinalIgnoreCase))
+                    {
+                        Log.LogError("Unable to retrieve the culture for EmbeddedResource {0}. The file type is not supported.", file.ItemSpec);
+                        return false;
+                    }
+                    XmlDocument wxlFile = new XmlDocument();
+
+                    try
+                    {
+                        wxlFile.Load(file.ItemSpec);
+                    }
+                    catch (FileNotFoundException)
+                    {
+                        Log.LogError("Unable to retrieve the culture for EmbeddedResource {0}. The file was not found.", file.ItemSpec);
+                        return false;
+                    }
+                    catch (Exception e)
+                    {
+                        Log.LogError("Unable to retrieve the culture for EmbeddedResource {0}: {1}", file.ItemSpec, e.Message);
+                        return false;
+                    }
+
+                    // Take the culture value and try using it to create a culture.
+                    XmlAttribute cultureAttr = wxlFile.DocumentElement.Attributes[WixAssignCulture.CultureAttributeName];
+                    string wxlCulture = null == cultureAttr ? String.Empty : cultureAttr.Value;
+                    if (0 == wxlCulture.Length)
+                    {
+                        // We use a keyword for the invariant culture because MSBuild v2.0.50727 cannnot handle "" items
+                        wxlCulture = InvariantCultureIdentifier;
+                    }
+
+                    // We found the culture for the WXL, we now need to determine if it maps to a culture group specified
+                    // in the Cultures property or if we need to create a new one.
+                    Log.LogMessage(MessageImportance.Low, "Culture \"{0}\" from EmbeddedResource {1}.", wxlCulture, file.ItemSpec);
+
+                    bool cultureGroupExists = false;
+                    foreach (CultureGroup cultureGroup in cultureGroups)
+                    {
+                        foreach (string culture in cultureGroup.Cultures)
+                        {
+                            if (String.Equals(wxlCulture, culture, StringComparison.OrdinalIgnoreCase))
+                            {
+                                cultureGroupExists = true;
+                                break;
+                            }
+                        }
+                    }
+
+                    // The WXL didn't match a culture group we already have so create a new one.
+                    if (!cultureGroupExists)
+                    {
+                        cultureGroups.Add(new CultureGroup(wxlCulture));
+                    }
+                }
+            }
+
+            // If we didn't create any culture groups the culture was unspecificed and no WXLs were included
+            // Build an unlocalized target in the output folder
+            if (cultureGroups.Count == 0)
+            {
+                cultureGroups.Add(new CultureGroup());
+            }
+
+            List<TaskItem> cultureGroupItems = new List<TaskItem>();
+
+            if (1 == cultureGroups.Count && 0 == this.Files.Length)
+            {
+                // Maintain old behavior, if only one culturegroup is specified and no WXL, output to the default folder
+                TaskItem cultureGroupItem = new TaskItem(cultureGroups[0].ToString());
+                cultureGroupItem.SetMetadata(OutputFolderMetadataName, CultureGroup.DefaultFolder);
+                cultureGroupItems.Add(cultureGroupItem);
+            }
+            else
+            {
+                foreach (CultureGroup cultureGroup in cultureGroups)
+                {
+                    TaskItem cultureGroupItem = new TaskItem(cultureGroup.ToString());
+                    cultureGroupItem.SetMetadata(OutputFolderMetadataName, cultureGroup.OutputFolder);
+                    cultureGroupItems.Add(cultureGroupItem);
+                    Log.LogMessage("Culture: {0}", cultureGroup.ToString());
+                }
+            }
+
+            this.CultureGroups = cultureGroupItems.ToArray();
+            return true;
+        }
+
+        private class CultureGroup
+        {
+            private List<string> cultures = new List<string>();
+
+            /// <summary>
+            /// TargetPath already has a '\', do not double it!
+            /// </summary>
+            public const string DefaultFolder = "";
+
+            /// <summary>
+            /// Initialize a null culture group
+            /// </summary>
+            public CultureGroup()
+            {
+            }
+
+            public CultureGroup(string cultureGroupString)
+            {
+                Debug.Assert(!String.IsNullOrEmpty(cultureGroupString));
+                foreach (string cultureString in cultureGroupString.Split(','))
+                {
+                    this.cultures.Add(cultureString);
+                }
+            }
+
+            public List<string> Cultures { get { return cultures; } }
+
+            public string OutputFolder
+            {
+                get
+                {
+                    string result = DefaultFolder;
+                    if (this.Cultures.Count > 0 && 
+                        !this.Cultures[0].Equals(InvariantCultureIdentifier, StringComparison.OrdinalIgnoreCase))
+                    {
+                        result = this.Cultures[0] + "\\";
+                    }
+
+                    return result;
+                }
+            }
+
+            public override string ToString()
+            {
+                if (this.Cultures.Count > 0)
+                {
+                    return String.Join(",", this.Cultures.ToArray());
+                }
+
+                // We use a keyword for a null culture because MSBuild cannnot handle "" items
+                // Null is different from neutral.  For neutral we still want to do WXL
+                // filtering in Light.
+                return NullCultureIdentifier;
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.BuildTasks/WixCommandLineBuilder.cs b/src/WixToolset.BuildTasks/WixCommandLineBuilder.cs
new file mode 100644
index 00000000..9a6a005d
--- /dev/null
+++ b/src/WixToolset.BuildTasks/WixCommandLineBuilder.cs
@@ -0,0 +1,180 @@
+// 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.BuildTasks
+{
+    using System;
+    using System.Diagnostics;
+    using System.Globalization;
+    using System.IO;
+    using System.Text;
+
+    using Microsoft.Build.Framework;
+    using Microsoft.Build.Utilities;
+
+    /// <summary>
+    /// Helper class for appending the command line arguments.
+    /// </summary>
+    public class WixCommandLineBuilder : CommandLineBuilder
+    {
+        internal const int Unspecified = -1;
+        
+        /// <summary>
+        /// Append a switch to the command line if the value has been specified.
+        /// </summary>
+        /// <param name="switchName">Switch to append.</param>
+        /// <param name="value">Value specified by the user.</param>
+        public void AppendIfSpecified(string switchName, int value)
+        {
+            if (value != Unspecified)
+            {
+                this.AppendSwitchIfNotNull(switchName, value.ToString(CultureInfo.InvariantCulture));
+            }
+        }
+
+        /// <summary>
+        /// Append a switch to the command line if the condition is true.
+        /// </summary>
+        /// <param name="switchName">Switch to append.</param>
+        /// <param name="condition">Condition specified by the user.</param>
+        public void AppendIfTrue(string switchName, bool condition)
+        {
+            if (condition)
+            {
+                this.AppendSwitch(switchName);
+            }
+        }
+
+        /// <summary>
+        /// Append a switch to the command line if any values in the array have been specified.
+        /// </summary>
+        /// <param name="switchName">Switch to append.</param>
+        /// <param name="values">Values specified by the user.</param>
+        public void AppendArrayIfNotNull(string switchName, ITaskItem[] values)
+        {
+            if (values != null)
+            {
+                foreach (ITaskItem value in values)
+                {
+                    this.AppendSwitchIfNotNull(switchName, value);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Append a switch to the command line if any values in the array have been specified.
+        /// </summary>
+        /// <param name="switchName">Switch to append.</param>
+        /// <param name="values">Values specified by the user.</param>
+        public void AppendArrayIfNotNull(string switchName, string[] values)
+        {
+            if (values != null)
+            {
+                foreach (string value in values)
+                {
+                    this.AppendSwitchIfNotNull(switchName, value);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Build the extensions argument. Each extension is searched in the current folder, user defined search 
+        /// directories (ReferencePath), HintPath, and under Wix Extension Directory in that order.
+        /// The order of precednce is based off of that described in Microsoft.Common.Targets's SearchPaths
+        /// property for the ResolveAssemblyReferences task.
+        /// </summary>
+        /// <param name="extensions">The list of extensions to include.</param>
+        /// <param name="wixExtensionDirectory">Evaluated default folder for Wix Extensions</param>
+        /// <param name="referencePaths">User defined reference directories to search in</param>
+        public void AppendExtensions(ITaskItem[] extensions, string wixExtensionDirectory, string [] referencePaths)
+        {
+            if (extensions == null)
+            {
+                return;
+            }
+
+            string resolvedPath;
+
+            foreach (ITaskItem extension in extensions)
+            {
+                string className = extension.GetMetadata("Class");
+
+                string fileName = Path.GetFileName(extension.ItemSpec);
+
+                if (Path.GetExtension(fileName).Length == 0)
+                {
+                    fileName += ".dll";
+                }
+
+                // First try reference paths
+                resolvedPath = FileSearchHelperMethods.SearchFilePaths(referencePaths, fileName);
+
+                if (String.IsNullOrEmpty(resolvedPath))
+                {
+                    // Now try HintPath
+                    resolvedPath = extension.GetMetadata("HintPath");
+
+                    if (!File.Exists(resolvedPath))
+                    {
+                        // Now try the item itself
+                        resolvedPath = extension.ItemSpec;
+
+                        if (Path.GetExtension(resolvedPath).Length == 0)
+                        {
+                            resolvedPath += ".dll";
+                        }
+
+                        if (!File.Exists(resolvedPath))
+                        {
+                            if (!String.IsNullOrEmpty(wixExtensionDirectory))
+                            {
+                                // Now try the extension directory
+                                resolvedPath = Path.Combine(wixExtensionDirectory, Path.GetFileName(resolvedPath));
+                            }
+
+                            if (!File.Exists(resolvedPath))
+                            {
+                                // Extesnion wasn't found, just set it to the extension name passed in
+                                resolvedPath = extension.ItemSpec;
+                            }
+                        }
+                    }
+                }
+
+                if (String.IsNullOrEmpty(className))
+                {
+                    this.AppendSwitchIfNotNull("-ext ", resolvedPath);
+                }
+                else
+                {
+                    this.AppendSwitchIfNotNull("-ext ", className + ", " + resolvedPath);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Append arbitrary text to the command-line if specified.
+        /// </summary>
+        /// <param name="textToAppend">Text to append.</param>
+        public void AppendTextIfNotNull(string textToAppend)
+        {
+            if (!String.IsNullOrEmpty(textToAppend))
+            {
+                this.AppendSpaceIfNotEmpty();
+                this.AppendTextUnquoted(textToAppend);
+            }
+        }
+
+        /// <summary>
+        /// Append arbitrary text to the command-line if specified.
+        /// </summary>
+        /// <param name="textToAppend">Text to append.</param>
+        public void AppendTextIfNotWhitespace(string textToAppend)
+        {
+            if (!String.IsNullOrWhiteSpace(textToAppend))
+            {
+                this.AppendSpaceIfNotEmpty();
+                this.AppendTextUnquoted(textToAppend);
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.BuildTasks/WixToolTask.cs b/src/WixToolset.BuildTasks/WixToolTask.cs
new file mode 100644
index 00000000..2e5e8705
--- /dev/null
+++ b/src/WixToolset.BuildTasks/WixToolTask.cs
@@ -0,0 +1,406 @@
+// 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.BuildTasks
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Globalization;
+    using System.IO;
+    using System.Reflection;
+    using System.Text;
+    using System.Threading;
+
+    using Microsoft.Build.Framework;
+    using Microsoft.Build.Utilities;
+
+    /// <summary>
+    /// Base class for WiX tool tasks; executes tools in-process
+    /// so that repeated invocations are much faster.
+    /// </summary>
+    public abstract class WixToolTask : ToolTask, IDisposable
+    {
+        private string additionalOptions;
+        private bool disposed;
+        private bool noLogo;
+        private bool runAsSeparateProcess;
+        private bool suppressAllWarnings;
+        private string[] suppressSpecificWarnings;
+        private string[] treatSpecificWarningsAsErrors;
+        private bool treatWarningsAsErrors;
+        private bool verboseOutput;
+        private Queue<string> messageQueue;
+        private ManualResetEvent messagesAvailable;
+        private ManualResetEvent toolExited;
+        private int exitCode;
+
+        /// <summary>
+        /// Gets or sets additional options that are appended the the tool command-line.
+        /// </summary>
+        /// <remarks>
+        /// This allows the task to support extended options in the tool which are not
+        /// explicitly implemented as properties on the task.
+        /// </remarks>
+        public string AdditionalOptions
+        {
+            get { return this.additionalOptions; }
+            set { this.additionalOptions = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets a flag indicating whether the task should be run as separate
+        /// process instead of in-proc with MSBuild which is the default.
+        /// </summary>
+        public bool RunAsSeparateProcess
+        {
+            get { return this.runAsSeparateProcess; }
+            set { this.runAsSeparateProcess = value; }
+        }
+
+#region Common Options
+        /// <summary>
+        /// Gets or sets whether all warnings should be suppressed.
+        /// </summary>
+        public bool SuppressAllWarnings
+        {
+            get { return this.suppressAllWarnings; }
+            set { this.suppressAllWarnings = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets a list of specific warnings to be suppressed.
+        /// </summary>
+        public string[] SuppressSpecificWarnings
+        {
+            get { return this.suppressSpecificWarnings; }
+            set { this.suppressSpecificWarnings = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets whether all warnings should be treated as errors.
+        /// </summary>
+        public bool TreatWarningsAsErrors
+        {
+            get { return this.treatWarningsAsErrors; }
+            set { this.treatWarningsAsErrors = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets a list of specific warnings to treat as errors.
+        /// </summary>
+        public string[] TreatSpecificWarningsAsErrors
+        {
+            get { return this.treatSpecificWarningsAsErrors; }
+            set { this.treatSpecificWarningsAsErrors = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets whether to display verbose output.
+        /// </summary>
+        public bool VerboseOutput
+        {
+            get { return this.verboseOutput; }
+            set { this.verboseOutput = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets whether to display the logo.
+        /// </summary>
+        public bool NoLogo
+        {
+            get { return this.noLogo; }
+            set { this.noLogo = value; }
+        }
+#endregion
+
+        /// <summary>
+        /// Cleans up the ManualResetEvent members
+        /// </summary>
+        public void Dispose()
+        {
+            if (!this.disposed)
+            {
+                this.Dispose(true);
+                GC.SuppressFinalize(this);
+                disposed = true;
+            }
+        }
+
+        /// <summary>
+        /// Cleans up the ManualResetEvent members
+        /// </summary>
+        protected virtual void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                messagesAvailable.Close();
+                toolExited.Close();
+            }
+        }
+
+        /// <summary>
+        /// Generate the command line arguments to write to the response file from the properties.
+        /// </summary>
+        /// <returns>Command line string.</returns>
+        protected override string GenerateResponseFileCommands()
+        {
+            WixCommandLineBuilder commandLineBuilder = new WixCommandLineBuilder();
+            this.BuildCommandLine(commandLineBuilder);
+            return commandLineBuilder.ToString();
+        }
+
+        /// <summary>
+        /// Builds a command line from options in this and derivative tasks.
+        /// </summary>
+        /// <remarks>
+        /// Derivative classes should call BuildCommandLine() on the base class to ensure that common command line options are added to the command.
+        /// </remarks>
+        protected virtual void BuildCommandLine(WixCommandLineBuilder commandLineBuilder)
+        {
+            commandLineBuilder.AppendIfTrue("-nologo", this.NoLogo);
+            commandLineBuilder.AppendArrayIfNotNull("-sw", this.SuppressSpecificWarnings);
+            commandLineBuilder.AppendIfTrue("-sw", this.SuppressAllWarnings);
+            commandLineBuilder.AppendIfTrue("-v", this.VerboseOutput);
+            commandLineBuilder.AppendArrayIfNotNull("-wx", this.TreatSpecificWarningsAsErrors);
+            commandLineBuilder.AppendIfTrue("-wx", this.TreatWarningsAsErrors);
+        }
+
+        /// <summary>
+        /// Executes a tool in-process by loading the tool assembly and invoking its entrypoint.
+        /// </summary>
+        /// <param name="pathToTool">Path to the tool to be executed; must be a managed executable.</param>
+        /// <param name="responseFileCommands">Commands to be written to a response file.</param>
+        /// <param name="commandLineCommands">Commands to be passed directly on the command-line.</param>
+        /// <returns>The tool exit code.</returns>
+        protected override int ExecuteTool(string pathToTool, string responseFileCommands, string commandLineCommands)
+        {
+            if (this.RunAsSeparateProcess)
+            {
+                return base.ExecuteTool(pathToTool, responseFileCommands, commandLineCommands);
+            }
+
+            this.messageQueue = new Queue<string>();
+            this.messagesAvailable = new ManualResetEvent(false);
+            this.toolExited = new ManualResetEvent(false);
+
+            Util.RunningInMsBuild = true;
+
+            WixToolTaskLogger logger = new WixToolTaskLogger(this.messageQueue, this.messagesAvailable);
+            TextWriter saveConsoleOut = Console.Out;
+            TextWriter saveConsoleError = Console.Error;
+            Console.SetOut(logger);
+            Console.SetError(logger);
+
+            string responseFile = null;
+            try
+            {
+                string responseFileSwitch;
+                responseFile = this.GetTemporaryResponseFile(responseFileCommands, out responseFileSwitch);
+                if (!String.IsNullOrEmpty(responseFileSwitch))
+                {
+                    commandLineCommands = commandLineCommands + " " + responseFileSwitch;
+                }
+
+                string[] arguments = CommandLineResponseFile.ParseArgumentsToArray(commandLineCommands);
+
+                Thread toolThread = new Thread(new ParameterizedThreadStart(this.ExecuteToolThread));
+                toolThread.Start(new object[] { pathToTool, arguments });
+
+                this.HandleToolMessages();
+
+                if (this.exitCode == 0 && this.Log.HasLoggedErrors)
+                {
+                    this.exitCode = -1;
+                }
+
+                return this.exitCode;
+            }
+            finally
+            {
+                if (responseFile != null)
+                {
+                    File.Delete(responseFile);
+                }
+
+                Console.SetOut(saveConsoleOut);
+                Console.SetError(saveConsoleError);
+            }
+        }
+
+        /// <summary>
+        /// Called by a new thread to execute the tool in that thread.
+        /// </summary>
+        /// <param name="parameters">Tool path and arguments array.</param>
+        private void ExecuteToolThread(object parameters)
+        {
+            try
+            {
+                object[] pathAndArguments = (object[])parameters;
+                Assembly toolAssembly = Assembly.LoadFrom((string)pathAndArguments[0]);
+                this.exitCode = (int)toolAssembly.EntryPoint.Invoke(null, new object[] { pathAndArguments[1] });
+            }
+            catch (FileNotFoundException fnfe)
+            {
+                Log.LogError("Unable to load tool from path {0}.  Consider setting the ToolPath parameter to $(WixToolPath).", fnfe.FileName);
+                this.exitCode = -1;
+            }
+            catch (Exception ex)
+            {
+                this.exitCode = -1;
+                this.LogEventsFromTextOutput(ex.Message, MessageImportance.High);
+                foreach (string stackTraceLine in ex.StackTrace.Split('\n'))
+                {
+                    this.LogEventsFromTextOutput(stackTraceLine.TrimEnd(), MessageImportance.High);
+                }
+
+                throw;
+            }
+            finally
+            {
+                this.toolExited.Set();
+            }
+        }
+
+        /// <summary>
+        /// Waits for messages from the tool thread and sends them to the MSBuild logger on the original thread.
+        /// Returns when the tool thread exits.
+        /// </summary>
+        private void HandleToolMessages()
+        {
+            WaitHandle[] waitHandles = new WaitHandle[] { this.messagesAvailable, this.toolExited };
+            while (WaitHandle.WaitAny(waitHandles) == 0)
+            {
+                lock (this.messageQueue)
+                {
+                    while (this.messageQueue.Count > 0)
+                    {
+                        this.LogEventsFromTextOutput(messageQueue.Dequeue(), MessageImportance.Normal);
+                    }
+
+                    this.messagesAvailable.Reset();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Creates a temporary response file for tool execution.
+        /// </summary>
+        /// <returns>Path to the response file.</returns>
+        /// <remarks>
+        /// The temporary file should be deleted after the tool execution is finished.
+        /// </remarks>
+        private string GetTemporaryResponseFile(string responseFileCommands, out string responseFileSwitch)
+        {
+            string responseFile = null;
+            responseFileSwitch = null;
+
+            if (!String.IsNullOrEmpty(responseFileCommands))
+            {
+                responseFile = Path.GetTempFileName();
+                using (StreamWriter writer = new StreamWriter(responseFile, false, this.ResponseFileEncoding))
+                {
+                    writer.Write(responseFileCommands);
+                }
+                responseFileSwitch = this.GetResponseFileSwitch(responseFile);
+            }
+            return responseFile;
+        }
+
+        /// <summary>
+        /// Cycles thru each task to find correct path of the file in question.
+        /// Looks at item spec, hintpath and then in user defined Reference Paths
+        /// </summary>
+        /// <param name="tasks">Input task array</param>
+        /// <param name="referencePaths">SemiColon delimited directories to search</param>
+        /// <returns>List of task item file paths</returns>
+        [SuppressMessage("Microsoft.Design", "CA1002:DoNotExposeGenericLists")]
+        protected static List<string> AdjustFilePaths(ITaskItem[] tasks, string[] referencePaths)
+        {
+            List<string> sourceFilePaths = new List<string>();
+
+            if (tasks == null)
+            {
+                return sourceFilePaths;
+            }
+
+            foreach (ITaskItem task in tasks)
+            {
+                string filePath = task.ItemSpec;
+                if (!File.Exists(filePath))
+                {
+                    filePath = task.GetMetadata("HintPath");
+                    if (!File.Exists(filePath))
+                    {
+                        string searchPath = FileSearchHelperMethods.SearchFilePaths(referencePaths, filePath);
+                        if (!String.IsNullOrEmpty(searchPath))
+                        {
+                            filePath = searchPath;
+                        }
+                    }
+                }
+                sourceFilePaths.Add(filePath);
+            }
+
+            return sourceFilePaths;
+        }
+
+        /// <summary>
+        /// Used as a replacement for Console.Out to capture output from a tool
+        /// and redirect it to the MSBuild logging system.
+        /// </summary>
+        private class WixToolTaskLogger : TextWriter
+        {
+            private StringBuilder buffer;
+            private Queue<string> messageQueue;
+            private ManualResetEvent messagesAvailable;
+
+            /// <summary>
+            /// Creates a new logger that sends tool output to the tool task's log handler.
+            /// </summary>
+            public WixToolTaskLogger(Queue<string> messageQueue, ManualResetEvent messagesAvailable) : base(CultureInfo.CurrentCulture)
+            {
+                this.messageQueue = messageQueue;
+                this.messagesAvailable = messagesAvailable;
+                this.buffer = new StringBuilder();
+            }
+
+            /// <summary>
+            /// Gets the encoding of the logger.
+            /// </summary>
+            public override Encoding Encoding
+            {
+                get { return Encoding.Unicode; }
+            }
+
+            /// <summary>
+            /// Redirects output to a buffer; watches for newlines and sends each line to the
+            /// MSBuild logging system.
+            /// </summary>
+            /// <param name="value">Character being written.</param>
+            /// <remarks>All other Write() variants eventually call into this one.</remarks>
+            public override void Write(char value)
+            {
+                lock (this.messageQueue)
+                {
+                    if (value == '\n')
+                    {
+                        if (this.buffer.Length > 0 && this.buffer[this.buffer.Length - 1] == '\r')
+                        {
+                            this.buffer.Length = this.buffer.Length - 1;
+                        }
+
+                        this.messageQueue.Enqueue(this.buffer.ToString());
+                        this.messagesAvailable.Set();
+
+                        this.buffer.Length = 0;
+                    }
+                    else
+                    {
+                        this.buffer.Append(value);
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.BuildTasks/WixToolset.BuildTasks.csproj b/src/WixToolset.BuildTasks/WixToolset.BuildTasks.csproj
new file mode 100644
index 00000000..34a1a9f5
--- /dev/null
+++ b/src/WixToolset.BuildTasks/WixToolset.BuildTasks.csproj
@@ -0,0 +1,38 @@
+<?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>
+    <TargetFramework>net462</TargetFramework>
+    <Description></Description>
+    <Title>WiX Toolset MSBuild Tasks</Title>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <!-- <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies> -->
+    <NoWarn>NU1701</NoWarn>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Content Include="redirect.wix.targets" CopyToOutputDirectory="PreserveNewest" />
+    <Content Include="redirect.wix.ca.targets" CopyToOutputDirectory="PreserveNewest" />
+    <Content Include="wix.targets" CopyToOutputDirectory="PreserveNewest" />
+    <Content Include="wix.ca.targets" CopyToOutputDirectory="PreserveNewest" />
+    <Content Include="wix.harvest.targets" CopyToOutputDirectory="PreserveNewest" />
+    <Content Include="wix.signing.targets" CopyToOutputDirectory="PreserveNewest" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\WixToolset.Core\WixToolset.Core.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="WixToolset.Dtf.WindowsInstaller" Version="4.0.*" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Nerdbank.GitVersioning" Version="2.0.41" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.Build.Tasks.Core" Version="14.3" PrivateAssets="all" Condition="'$(TargetFramework)'=='net462' " />
+    <PackageReference Include="Microsoft.Build.Tasks.Core" Version="15.3.409" PrivateAssets="all" Condition="'$(TargetFramework)'=='netstandard2.0' " />
+  </ItemGroup>
+</Project>
diff --git a/src/WixToolset.BuildTasks/heatdirectory.cs b/src/WixToolset.BuildTasks/heatdirectory.cs
new file mode 100644
index 00000000..1d5f104a
--- /dev/null
+++ b/src/WixToolset.BuildTasks/heatdirectory.cs
@@ -0,0 +1,103 @@
+// 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.BuildTasks
+{
+    using Microsoft.Build.Framework;
+
+    public sealed class HeatDirectory : HeatTask
+    {
+        private string directory;
+        private bool keepEmptyDirectories;
+        private bool suppressCom;
+        private bool suppressRootDirectory;
+        private bool suppressRegistry;
+        private string template;
+        private string componentGroupName;
+        private string directoryRefId;
+        private string preprocessorVariable;
+
+        public string ComponentGroupName
+        {
+            get { return this.componentGroupName; }
+            set { this.componentGroupName = value; }
+        }
+
+        [Required]
+        public string Directory
+        {
+            get { return this.directory; }
+            set { this.directory = value; }
+        }
+
+        public string DirectoryRefId
+        {
+            get { return this.directoryRefId; }
+            set { this.directoryRefId = value; }
+        }
+
+        public bool KeepEmptyDirectories
+        {
+            get { return this.keepEmptyDirectories; }
+            set { this.keepEmptyDirectories = value; }
+        }
+
+        public string PreprocessorVariable
+        {
+            get { return this.preprocessorVariable; }
+            set { this.preprocessorVariable = value; }
+        }
+
+        public bool SuppressCom
+        {
+            get { return this.suppressCom; }
+            set { this.suppressCom = value; }
+        }
+
+        public bool SuppressRootDirectory
+        {
+            get { return this.suppressRootDirectory; }
+            set { this.suppressRootDirectory = value; }
+        }
+
+        public bool SuppressRegistry
+        {
+            get { return this.suppressRegistry; }
+            set { this.suppressRegistry = value; }
+        }
+
+        public string Template
+        {
+            get { return this.template; }
+            set { this.template = value; }
+        }
+
+        protected override string OperationName
+        {
+            get { return "dir"; }
+        }
+
+        /// <summary>
+        /// Generate the command line arguments to write to the response file from the properties.
+        /// </summary>
+        /// <returns>Command line string.</returns>
+        protected override string GenerateResponseFileCommands()
+        {
+            WixCommandLineBuilder commandLineBuilder = new WixCommandLineBuilder();
+
+            commandLineBuilder.AppendSwitch(this.OperationName);
+            commandLineBuilder.AppendFileNameIfNotNull(this.Directory);
+
+            commandLineBuilder.AppendSwitchIfNotNull("-cg ", this.ComponentGroupName);
+            commandLineBuilder.AppendSwitchIfNotNull("-dr ", this.DirectoryRefId);
+            commandLineBuilder.AppendIfTrue("-ke", this.KeepEmptyDirectories);
+            commandLineBuilder.AppendIfTrue("-scom", this.SuppressCom);
+            commandLineBuilder.AppendIfTrue("-sreg", this.SuppressRegistry);
+            commandLineBuilder.AppendIfTrue("-srd", this.SuppressRootDirectory);
+            commandLineBuilder.AppendSwitchIfNotNull("-template ", this.Template);
+            commandLineBuilder.AppendSwitchIfNotNull("-var ", this.PreprocessorVariable);
+
+            base.BuildCommandLine(commandLineBuilder);
+            return commandLineBuilder.ToString();
+        }
+    }
+}
diff --git a/src/WixToolset.BuildTasks/heatfile.cs b/src/WixToolset.BuildTasks/heatfile.cs
new file mode 100644
index 00000000..69e11b88
--- /dev/null
+++ b/src/WixToolset.BuildTasks/heatfile.cs
@@ -0,0 +1,95 @@
+// 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.BuildTasks
+{
+    using Microsoft.Build.Framework;
+
+    public sealed class HeatFile : HeatTask
+    {
+        private string file;
+        private bool suppressCom;
+        private bool suppressRegistry;
+        private bool suppressRootDirectory;
+        private string template;
+        private string componentGroupName;
+        private string directoryRefId;
+        private string preprocessorVariable;
+
+        public string ComponentGroupName
+        {
+            get { return this.componentGroupName; }
+            set { this.componentGroupName = value; }
+        }
+
+        public string DirectoryRefId
+        {
+            get { return this.directoryRefId; }
+            set { this.directoryRefId = value; }
+        }
+
+        [Required]
+        public string File
+        {
+            get { return this.file; }
+            set { this.file = value; }
+        }
+
+        public string PreprocessorVariable
+        {
+            get { return this.preprocessorVariable; }
+            set { this.preprocessorVariable = value; }
+        }
+
+        public bool SuppressCom
+        {
+            get { return this.suppressCom; }
+            set { this.suppressCom = value; }
+        }
+
+        public bool SuppressRegistry
+        {
+            get { return this.suppressRegistry; }
+            set { this.suppressRegistry = value; }
+        }
+
+        public bool SuppressRootDirectory
+        {
+            get { return this.suppressRootDirectory; }
+            set { this.suppressRootDirectory = value; }
+        }
+
+        public string Template
+        {
+            get { return this.template; }
+            set { this.template = value; }
+        }
+
+        protected override string OperationName
+        {
+            get { return "file"; }
+        }
+
+        /// <summary>
+        /// Generate the command line arguments to write to the response file from the properties.
+        /// </summary>
+        /// <returns>Command line string.</returns>
+        protected override string GenerateResponseFileCommands()
+        {
+            WixCommandLineBuilder commandLineBuilder = new WixCommandLineBuilder();
+
+            commandLineBuilder.AppendSwitch(this.OperationName);
+            commandLineBuilder.AppendFileNameIfNotNull(this.File);
+
+            commandLineBuilder.AppendSwitchIfNotNull("-cg ", this.ComponentGroupName);
+            commandLineBuilder.AppendSwitchIfNotNull("-dr ", this.DirectoryRefId);
+            commandLineBuilder.AppendIfTrue("-scom", this.SuppressCom);
+            commandLineBuilder.AppendIfTrue("-srd", this.SuppressRootDirectory);
+            commandLineBuilder.AppendIfTrue("-sreg", this.SuppressRegistry);
+            commandLineBuilder.AppendSwitchIfNotNull("-template ", this.Template);
+            commandLineBuilder.AppendSwitchIfNotNull("-var ", this.PreprocessorVariable);
+
+            base.BuildCommandLine(commandLineBuilder);
+            return commandLineBuilder.ToString();
+        }
+    }
+}
diff --git a/src/WixToolset.BuildTasks/heatproject.cs b/src/WixToolset.BuildTasks/heatproject.cs
new file mode 100644
index 00000000..8620ffa3
--- /dev/null
+++ b/src/WixToolset.BuildTasks/heatproject.cs
@@ -0,0 +1,108 @@
+// 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.BuildTasks
+{
+    using Microsoft.Build.Framework;
+
+    public sealed class HeatProject : HeatTask
+    {
+        private string configuration;
+        private string directoryIds;
+        private string generateType;
+        private bool generateWixVariables;
+        private string platform;
+        private string project;
+        private string projectName;
+        private string[] projectOutputGroups;
+
+        public string Configuration
+        {
+            get { return this.configuration; }
+            set { this.configuration = value; }
+        }
+
+        public string DirectoryIds
+        {
+            get { return this.directoryIds; }
+            set { this.directoryIds = value; }
+        }
+
+        public bool GenerateWixVariables
+        {
+            get { return this.generateWixVariables; }
+            set { this.generateWixVariables = value; }
+        }
+
+        public string GenerateType
+        {
+            get { return this.generateType; }
+            set { this.generateType = value; }
+        }
+
+        public string Platform
+        {
+            get { return this.platform; }
+            set { this.platform = value; }
+        }
+
+        [Required]
+        public string Project
+        {
+            get { return this.project; }
+            set { this.project = value; }
+        }
+
+        public string ProjectName
+        {
+            get { return this.projectName; }
+            set { this.projectName = value; }
+        }
+
+        public string[] ProjectOutputGroups
+        {
+            get
+            {
+                return this.projectOutputGroups;
+            }
+            set
+            {
+                this.projectOutputGroups = value;
+
+                // If it's just one string and it contains semicolons, let's
+                // split it into separate items.
+                if (this.projectOutputGroups.Length == 1)
+                {
+                    this.projectOutputGroups = this.projectOutputGroups[0].Split(new char[] { ';' });
+                }
+            }
+        }
+
+        protected override string OperationName
+        {
+            get { return "project"; }
+        }
+
+        /// <summary>
+        /// Generate the command line arguments to write to the response file from the properties.
+        /// </summary>
+        /// <returns>Command line string.</returns>
+        protected override string GenerateResponseFileCommands()
+        {
+            WixCommandLineBuilder commandLineBuilder = new WixCommandLineBuilder();
+
+            commandLineBuilder.AppendSwitch(this.OperationName);
+            commandLineBuilder.AppendFileNameIfNotNull(this.Project);
+
+            commandLineBuilder.AppendSwitchIfNotNull("-configuration ", this.Configuration);
+            commandLineBuilder.AppendSwitchIfNotNull("-directoryid ", this.DirectoryIds);
+            commandLineBuilder.AppendSwitchIfNotNull("-generate ", this.GenerateType);
+            commandLineBuilder.AppendSwitchIfNotNull("-platform ", this.Platform);
+            commandLineBuilder.AppendArrayIfNotNull("-pog ", this.ProjectOutputGroups);
+            commandLineBuilder.AppendSwitchIfNotNull("-projectname ", this.ProjectName);
+            commandLineBuilder.AppendIfTrue("-wixvar", this.GenerateWixVariables);
+
+            base.BuildCommandLine(commandLineBuilder);
+            return commandLineBuilder.ToString();
+        }
+    }
+}
diff --git a/src/WixToolset.BuildTasks/heattask.cs b/src/WixToolset.BuildTasks/heattask.cs
new file mode 100644
index 00000000..bf0a2ad3
--- /dev/null
+++ b/src/WixToolset.BuildTasks/heattask.cs
@@ -0,0 +1,121 @@
+// 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.BuildTasks
+{
+    using System;
+    using System.Diagnostics;
+    using System.Globalization;
+    using System.IO;
+    using System.Text;
+
+    using Microsoft.Build.Framework;
+    using Microsoft.Build.Utilities;
+
+    /// <summary>
+    /// A base MSBuild task to run the WiX harvester.
+    /// Specific harvester tasks should extend this class.
+    /// </summary>
+    public abstract class HeatTask : WixToolTask
+    {
+        private const string HeatToolName = "Heat.exe";
+
+        private bool autogenerageGuids;
+        private bool generateGuidsNow;
+        private ITaskItem outputFile;
+        private bool suppressFragments;
+        private bool suppressUniqueIds;
+        private string[] transforms;
+
+        public bool AutogenerateGuids
+        {
+            get { return this.autogenerageGuids; }
+            set { this.autogenerageGuids = value; }
+        }
+
+        public bool GenerateGuidsNow
+        {
+            get { return this.generateGuidsNow; }
+            set { this.generateGuidsNow = value; }
+        }
+
+        [Required]
+        [Output]
+        public ITaskItem OutputFile
+        {
+            get { return this.outputFile; }
+            set { this.outputFile = value; }
+        }
+
+        public bool SuppressFragments
+        {
+            get { return this.suppressFragments; }
+            set { this.suppressFragments = value; }
+        }
+
+        public bool SuppressUniqueIds
+        {
+            get { return this.suppressUniqueIds; }
+            set { this.suppressUniqueIds = value; }
+        }
+
+        public string[] Transforms
+        {
+            get { return this.transforms; }
+            set { this.transforms = value; }
+        }
+
+        /// <summary>
+        /// Get the name of the executable.
+        /// </summary>
+        /// <remarks>The ToolName is used with the ToolPath to get the location of heat.exe.</remarks>
+        /// <value>The name of the executable.</value>
+        protected override string ToolName
+        {
+            get { return HeatToolName; }
+        }
+
+        /// <summary>
+        /// Gets the name of the heat operation performed by the task.
+        /// </summary>
+        /// <remarks>This is the first parameter passed on the heat.exe command-line.</remarks>
+        /// <value>The name of the heat operation performed by the task.</value>
+        protected abstract string OperationName
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Get the path to the executable. 
+        /// </summary>
+        /// <remarks>GetFullPathToTool is only called when the ToolPath property is not set (see the ToolName remarks above).</remarks>
+        /// <returns>The full path to the executable or simply heat.exe if it's expected to be in the system path.</returns>
+        protected override string GenerateFullPathToTool()
+        {
+            // If there's not a ToolPath specified, it has to be in the system path.
+            if (String.IsNullOrEmpty(this.ToolPath))
+            {
+                return HeatToolName;
+            }
+
+            return Path.Combine(Path.GetFullPath(this.ToolPath), HeatToolName);
+        }
+
+        /// <summary>
+        /// Builds a command line from options in this task.
+        /// </summary>
+        protected override void BuildCommandLine(WixCommandLineBuilder commandLineBuilder)
+        {
+            base.BuildCommandLine(commandLineBuilder);
+
+            commandLineBuilder.AppendIfTrue("-ag", this.AutogenerateGuids);
+            commandLineBuilder.AppendIfTrue("-gg", this.GenerateGuidsNow);
+            commandLineBuilder.AppendIfTrue("-nologo", this.NoLogo);
+            commandLineBuilder.AppendIfTrue("-sfrag", this.SuppressFragments);
+            commandLineBuilder.AppendIfTrue("-suid", this.SuppressUniqueIds);
+            commandLineBuilder.AppendArrayIfNotNull("-sw", this.SuppressSpecificWarnings);
+            commandLineBuilder.AppendArrayIfNotNull("-t ", this.Transforms);
+            commandLineBuilder.AppendTextIfNotNull(this.AdditionalOptions);
+            commandLineBuilder.AppendSwitchIfNotNull("-out ", this.OutputFile);
+        }
+    }
+}
diff --git a/src/WixToolset.BuildTasks/redirect.wix.ca.targets b/src/WixToolset.BuildTasks/redirect.wix.ca.targets
new file mode 100644
index 00000000..74e6ec3c
--- /dev/null
+++ b/src/WixToolset.BuildTasks/redirect.wix.ca.targets
@@ -0,0 +1,11 @@
+<?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 xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
+  <PropertyGroup>
+    <WixInstallFolder>$([MSBuild]::GetRegistryValueFromView('HKEY_LOCAL_MACHINE\SOFTWARE\WiX Toolset\v4', 'InstallFolder', null, RegistryView.Registry32))</WixInstallFolder>
+  </PropertyGroup>
+
+  <Import Project="$(WixInstallFolder)sdk\wix.ca.targets" />
+</Project>
diff --git a/src/WixToolset.BuildTasks/redirect.wix.targets b/src/WixToolset.BuildTasks/redirect.wix.targets
new file mode 100644
index 00000000..b40c4c36
--- /dev/null
+++ b/src/WixToolset.BuildTasks/redirect.wix.targets
@@ -0,0 +1,11 @@
+<?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 xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
+  <PropertyGroup>
+    <WixInstallFolder>$([MSBuild]::GetRegistryValueFromView('HKEY_LOCAL_MACHINE\SOFTWARE\WiX Toolset\v4', 'InstallFolder', null, RegistryView.Registry32))</WixInstallFolder>
+  </PropertyGroup>
+
+  <Import Project="$(WixInstallFolder)bin\wix.targets" />
+</Project>
diff --git a/src/WixToolset.BuildTasks/wix.ca.targets b/src/WixToolset.BuildTasks/wix.ca.targets
new file mode 100644
index 00000000..4578c2d8
--- /dev/null
+++ b/src/WixToolset.BuildTasks/wix.ca.targets
@@ -0,0 +1,123 @@
+<?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 xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
+
+  <Import Project="$(CustomBeforeWixCATargets)" Condition=" '$(CustomBeforeWixCATargets)' != '' and Exists('$(CustomBeforeWixCATargets)')" />
+
+  <PropertyGroup>
+    <WixCATargetsImported>true</WixCATargetsImported>
+
+    <TargetCAFileName Condition=" '$(TargetCAFileName)' == '' ">$(TargetName).CA$(TargetExt)</TargetCAFileName>
+
+    <WixSdkPath Condition=" '$(WixSdkPath)' == '' ">$(MSBuildThisFileDirectory)</WixSdkPath>
+    <WixSdkX86Path Condition=" '$(WixSdkX86Path)' == '' ">$(WixSdkPath)x86\</WixSdkX86Path>
+    <WixSdkX64Path Condition=" '$(WixSdkX64Path)' == '' ">$(WixSdkPath)x64\</WixSdkX64Path>
+
+    <MakeSfxCA Condition=" '$(MakeSfxCA)' == '' ">$(WixSdkPath)MakeSfxCA.exe</MakeSfxCA>
+    <SfxCADll Condition=" '$(SfxCADll)' == '' and '$(Platform)' == 'x64' ">$(WixSdkX64Path)SfxCA.dll</SfxCADll>
+    <SfxCADll Condition=" '$(SfxCADll)' == '' ">$(WixSdkX86Path)SfxCA.dll</SfxCADll>
+  </PropertyGroup>
+
+  <!--
+  ==================================================================================================
+  PackCustomAction
+
+    Creates an MSI managed custom action package that includes the custom action assembly,
+    local assembly dependencies, and project content files.
+
+    [IN]
+    @(IntermediateAssembly) - Managed custom action assembly.
+    @(Content) - Project items of type Content will be included in the package.
+    $(CustomActionContents) - Optional space-delimited list of additional files to include.
+    
+    [OUT]
+    $(IntermediateOutputPath)$(TargetCAFileName) - Managed custom action package with unmanaged stub.
+  ==================================================================================================
+  -->
+  <Target Name="PackCustomAction"
+          Inputs="@(IntermediateAssembly);@(Content);$(CustomActionContents)"
+          Outputs="$(IntermediateOutputPath)$(TargetCAFileName)">
+
+    <!-- Find all referenced items marked CopyLocal, but exclude non-binary files. -->
+    <ItemGroup>
+      <CustomActionReferenceContents Include="@(ReferenceCopyLocalPaths)"
+                                     Condition=" '%(Extension)' == '.dll' or '%(Extension)' == '.exe' " />
+      <CustomActionReferenceContents Include="@(ReferenceComWrappersToCopyLocal)"
+                                     Condition=" '%(Extension)' == '.dll' or '%(Extension)' == '.exe' " />
+    
+      <!-- include PDBs for Debug only -->
+      <CustomActionReferenceContents Include="@(IntermediateAssembly->'%(RootDir)%(Directory)%(Filename).pdb')"
+                                     Condition=" Exists('%(RootDir)%(Directory)%(Filename).pdb') and '$(Configuration)' == 'Debug' " />
+      <CustomActionReferenceContents Include="@(ReferenceCopyLocalPaths)"
+                                     Condition=" '%(Extension)' == '.pdb' and '$(Configuration)' == 'Debug' " />
+      <CustomActionReferenceContents Include="@(ReferenceComWrappersToCopyLocal)"
+                                     Condition=" '%(Extension)' == '.pdb' and '$(Configuration)' == 'Debug' " />
+    </ItemGroup>
+
+    <!--
+      Items to include in the CA package:
+         - Reference assemblies marked CopyLocal
+         - Project items of type Content
+         - Additional items in the CustomActionContents property
+    -->
+    <PropertyGroup>
+      <CustomActionContents>@(CustomActionReferenceContents);@(Content->'%(FullPath)');$(CustomActionContents)</CustomActionContents>
+    </PropertyGroup>
+
+    <ItemGroup>
+      <IntermediateCAAssembly Include="@(IntermediateAssembly->'%(FullPath)')" />
+      <IntermediateCAPackage Include="@(IntermediateAssembly->'%(RootDir)%(Directory)$(TargetCAFileName)')" />
+    </ItemGroup>
+
+    <!-- Run the MakeSfxCA.exe CA packaging tool. -->
+    <Exec Command='"$(MakeSfxCA)" "@(IntermediateCAPackage)" "$(SfxCADll)" "@(IntermediateCAAssembly)" "$(CustomActionContents)"'
+          WorkingDirectory="$(ProjectDir)" />
+  
+    <!-- Add modules to be copied to output dir. -->
+    <ItemGroup>
+      <AddModules Include="@(IntermediateCAPackage)" />
+    </ItemGroup>
+  </Target>
+
+  <!--
+  ==================================================================================================
+  CleanCustomAction
+
+    Cleans the .CA.dll binary created by the PackCustomAction target.
+
+  ==================================================================================================
+  -->
+  <Target Name="CleanCustomAction">
+    <Delete Files="$(IntermediateOutputPath)$(TargetCAFileName)"
+            TreatErrorsAsWarnings="true" />
+  </Target>
+
+  <!--
+  ==================================================================================================
+  AfterCompile (redefinition)
+
+    Calls the PackCustomAction target after compiling.
+    Overrides the empty AfterCompile target from Microsoft.Common.targets.
+
+  ==================================================================================================
+  -->
+  <Target Name="AfterCompile"
+          DependsOnTargets="PackCustomAction" />
+
+  <!--
+  ==================================================================================================
+  BeforeClean (redefinition)
+
+    Calls the CleanCustomAction target before cleaning.
+    Overrides the empty AfterCompile target from Microsoft.Common.targets.
+
+  ==================================================================================================
+  -->
+  <Target Name="BeforeClean"
+          DependsOnTargets="CleanCustomAction" />
+
+  <Import Project="$(CustomAfterWixCATargets)" Condition=" '$(CustomAfterWixCATargets)' != '' and Exists('$(CustomAfterWixCATargets)')" />
+
+</Project>
diff --git a/src/WixToolset.BuildTasks/wix.harvest.targets b/src/WixToolset.BuildTasks/wix.harvest.targets
new file mode 100644
index 00000000..e94dfcea
--- /dev/null
+++ b/src/WixToolset.BuildTasks/wix.harvest.targets
@@ -0,0 +1,511 @@
+<?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 xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+
+  <!-- These properties can be overridden to support non-default installations. -->
+  <PropertyGroup>
+    <WixTargetsPath Condition=" '$(WixTargetsPath)' == '' ">$(MSBuildThisFileFullPath)</WixTargetsPath>
+    <WixTasksPath Condition=" '$(WixTasksPath)' == '' ">$(WixTargetsPath)WixTasks.dll</WixTasksPath>
+  </PropertyGroup>
+
+  <!-- These tasks are extensions for harvesting WiX source code from other sources. -->
+  <UsingTask TaskName="HeatFile" AssemblyFile="$(WixTasksPath)" />
+  <UsingTask TaskName="HeatDirectory" AssemblyFile="$(WixTasksPath)" />
+  <UsingTask TaskName="HeatProject" AssemblyFile="$(WixTasksPath)" />
+
+  <UsingTask TaskName="RefreshGeneratedFile" AssemblyFile="$(WixTasksPath)"/>
+  <UsingTask TaskName="RefreshBundleGeneratedFile" AssemblyFile="$(WixTasksPath)"/>
+
+  <!-- Default Harvester properties-->
+  <PropertyGroup>
+    <HarvestNoLogo Condition=" '$(HarvestNoLogo)' == '' ">$(NoLogo)</HarvestNoLogo>
+    <HarvestSuppressAllWarnings Condition=" '$(HarvestSuppressAllWarnings)' == '' ">$(SuppressAllWarnings)</HarvestSuppressAllWarnings>
+    <HarvestSuppressSpecificWarnings Condition=" '$(HarvestSuppressSpecificWarnings)' == '' ">$(SuppressSpecificWarnings)</HarvestSuppressSpecificWarnings>
+    <HarvestTreatWarningsAsErrors Condition=" '$(HarvestTreatWarningsAsErrors)' == '' ">$(TreatWarningsAsErrors)</HarvestTreatWarningsAsErrors>
+    <HarvestTreatSpecificWarningsAsErrors Condition=" '$(HarvestTreatSpecificWarningsAsErrors)' == '' ">$(TreatSpecificWarningsAsErrors)</HarvestTreatSpecificWarningsAsErrors>
+    <HarvestVerboseOutput Condition=" '$(HarvestVerboseOutput)' == '' ">$(VerboseOutput)</HarvestVerboseOutput>
+    <HarvestAutogenerateGuids Condition=" '$(HarvestAutogenerateGuids)' == '' ">true</HarvestAutogenerateGuids>
+    <HarvestGenerateGuidsNow Condition=" '$(HarvestGenerateGuidsNow)' == '' ">false</HarvestGenerateGuidsNow>
+    <HarvestSuppressFragments Condition=" '$(HarvestSuppressFragments)' == '' ">true</HarvestSuppressFragments>
+    <HarvestSuppressUniqueIds Condition=" '$(HarvestSuppressUniqueIds)' == '' ">false</HarvestSuppressUniqueIds>
+  </PropertyGroup>
+
+  <!-- Default HarvestProjects properties -->
+  <PropertyGroup>
+    <!-- Project harvesting is defaulted to off until it works more consistently. -->
+    <EnableProjectHarvesting Condition=" '$(EnableProjectHarvesting)'=='' ">false</EnableProjectHarvesting>
+
+    <HarvestProjectsNoLogo Condition=" '$(HarvestProjectsNoLogo)' == '' ">$(HarvestNoLogo)</HarvestProjectsNoLogo>
+    <HarvestProjectsSuppressAllWarnings Condition=" '$(HarvestProjectsSuppressAllWarnings)' == '' ">$(HarvestSuppressAllWarnings)</HarvestProjectsSuppressAllWarnings>
+    <HarvestProjectsSuppressSpecificWarnings Condition=" '$(HarvestProjectsSuppressSpecificWarnings)' == '' ">$(HarvestSuppressSpecificWarnings)</HarvestProjectsSuppressSpecificWarnings>
+    <HarvestProjectsTreatWarningsAsErrors Condition=" '$(HarvestProjectsTreatWarningsAsErrors)' == '' ">$(HarvestTreatWarningsAsErrors)</HarvestProjectsTreatWarningsAsErrors>
+    <HarvestProjectsTreatSpecificWarningsAsErrors Condition=" '$(HarvestProjectsTreatSpecificWarningsAsErrors)' == '' ">$(HarvestTreatSpecificWarningsAsErrors)</HarvestProjectsTreatSpecificWarningsAsErrors>
+    <HarvestProjectsVerboseOutput Condition=" '$(HarvestProjectsVerboseOutput)' == '' ">$(HarvestVerboseOutput)</HarvestProjectsVerboseOutput>
+    <HarvestProjectsAutogenerateGuids Condition=" '$(HarvestProjectsAutogenerateGuids)' == '' ">$(HarvestAutogenerateGuids)</HarvestProjectsAutogenerateGuids>
+    <HarvestProjectsGenerateGuidsNow Condition=" '$(HarvestProjectsGenerateGuidsNow)' == '' ">$(HarvestGenerateGuidsNow)</HarvestProjectsGenerateGuidsNow>
+    <HarvestProjectsSuppressFragments Condition=" '$(HarvestProjectsSuppressFragments)' == '' ">$(HarvestSuppressFragments)</HarvestProjectsSuppressFragments>
+    <HarvestProjectsSuppressUniqueIds Condition=" '$(HarvestProjectsSuppressUniqueIds)' == '' ">$(HarvestSuppressUniqueIds)</HarvestProjectsSuppressUniqueIds>
+    <HarvestProjectsTransforms Condition=" '$(HarvestProjectsTransforms)' == '' ">$(HarvestTransforms)</HarvestProjectsTransforms>
+    <HarvestProjectsGeneratedFile Condition=" '$(HarvestProjectsGeneratedFile)' == '' and '$(OutputType)' != 'Bundle' ">$(IntermediateOutputPath)Product.Generated.wxs</HarvestProjectsGeneratedFile>
+    <HarvestProjectsGeneratedFile Condition=" '$(HarvestProjectsGeneratedFile)' == '' and '$(OutputType)' == 'Bundle' ">$(IntermediateOutputPath)Bundle.Generated.wxs</HarvestProjectsGeneratedFile>
+  </PropertyGroup>
+
+  <!-- Default HarvestDirectory properties -->
+  <PropertyGroup>
+    <HarvestDirectoryNoLogo Condition=" '$(HarvestDirectoryNoLogo)' == '' ">$(HarvestNoLogo)</HarvestDirectoryNoLogo>
+    <HarvestDirectorySuppressAllWarnings Condition=" '$(HarvestDirectorySuppressAllWarnings)' == '' ">$(HarvestSuppressAllWarnings)</HarvestDirectorySuppressAllWarnings>
+    <HarvestDirectorySuppressSpecificWarnings Condition=" '$(HarvestDirectorySuppressSpecificWarnings)' == '' ">$(HarvestSuppressSpecificWarnings)</HarvestDirectorySuppressSpecificWarnings>
+    <HarvestDirectoryTreatWarningsAsErrors Condition=" '$(HarvestDirectoryTreatWarningsAsErrors)' == '' ">$(HarvestTreatWarningsAsErrors)</HarvestDirectoryTreatWarningsAsErrors>
+    <HarvestDirectoryTreatSpecificWarningsAsErrors Condition=" '$(HarvestDirectoryTreatSpecificWarningsAsErrors)' == '' ">$(HarvestTreatSpecificWarningsAsErrors)</HarvestDirectoryTreatSpecificWarningsAsErrors>
+    <HarvestDirectoryVerboseOutput Condition=" '$(HarvestDirectoryVerboseOutput)' == '' ">$(HarvestVerboseOutput)</HarvestDirectoryVerboseOutput>
+    <HarvestDirectoryAutogenerateGuids Condition=" '$(HarvestDirectoryAutogenerateGuids)' == '' ">$(HarvestAutogenerateGuids)</HarvestDirectoryAutogenerateGuids>
+    <HarvestDirectoryGenerateGuidsNow Condition=" '$(HarvestDirectoryGenerateGuidsNow)' == '' ">$(HarvestGenerateGuidsNow)</HarvestDirectoryGenerateGuidsNow>
+    <HarvestDirectorySuppressFragments Condition=" '$(HarvestDirectorySuppressFragments)' == '' ">$(HarvestSuppressFragments)</HarvestDirectorySuppressFragments>
+    <HarvestDirectorySuppressUniqueIds Condition=" '$(HarvestDirectorySuppressUniqueIds)' == '' ">$(HarvestSuppressUniqueIds)</HarvestDirectorySuppressUniqueIds>
+    <HarvestDirectoryTransforms Condition=" '$(HarvestDirectoryTransforms)' == '' ">$(HarvestTransforms)</HarvestDirectoryTransforms>
+  </PropertyGroup>
+
+  <!-- Default HarvestFile properties -->
+  <PropertyGroup>
+    <HarvestFileNoLogo Condition=" '$(HarvestFileNoLogo)' == '' ">$(HarvestNoLogo)</HarvestFileNoLogo>
+    <HarvestFileSuppressAllWarnings Condition=" '$(HarvestFileSuppressAllWarnings)' == '' ">$(HarvestSuppressAllWarnings)</HarvestFileSuppressAllWarnings>
+    <HarvestFileSuppressSpecificWarnings Condition=" '$(HarvestFileSuppressSpecificWarnings)' == '' ">$(HarvestSuppressSpecificWarnings)</HarvestFileSuppressSpecificWarnings>
+    <HarvestFileTreatWarningsAsErrors Condition=" '$(HarvestFileTreatWarningsAsErrors)' == '' ">$(HarvestTreatWarningsAsErrors)</HarvestFileTreatWarningsAsErrors>
+    <HarvestFileTreatSpecificWarningsAsErrors Condition=" '$(HarvestFileTreatSpecificWarningsAsErrors)' == '' ">$(HarvestTreatSpecificWarningsAsErrors)</HarvestFileTreatSpecificWarningsAsErrors>
+    <HarvestFileVerboseOutput Condition=" '$(HarvestFileVerboseOutput)' == '' ">$(HarvestVerboseOutput)</HarvestFileVerboseOutput>
+    <HarvestFileAutogenerateGuids Condition=" '$(HarvestFileAutogenerateGuids)' == '' ">$(HarvestAutogenerateGuids)</HarvestFileAutogenerateGuids>
+    <HarvestFileGenerateGuidsNow Condition=" '$(HarvestFileGenerateGuidsNow)' == '' ">$(HarvestGenerateGuidsNow)</HarvestFileGenerateGuidsNow>
+    <HarvestFileSuppressFragments Condition=" '$(HarvestFileSuppressFragments)' == '' ">$(HarvestSuppressFragments)</HarvestFileSuppressFragments>
+    <HarvestFileSuppressUniqueIds Condition=" '$(HarvestFileSuppressUniqueIds)' == '' ">$(HarvestSuppressUniqueIds)</HarvestFileSuppressUniqueIds>
+    <HarvestFileTransforms Condition=" '$(HarvestFileTransforms)' == '' ">$(HarvestTransforms)</HarvestFileTransforms>
+  </PropertyGroup>
+
+  <!--
+  ==================================================================================================
+  Harvest
+  ==================================================================================================
+  -->
+  <PropertyGroup>
+    <HarvestDependsOn>
+      ConvertReferences;
+      ConvertBundleReferences;
+      HarvestProjects;
+      HarvestDirectory;
+      HarvestFile;
+      GenerateCode;
+    </HarvestDependsOn>
+  </PropertyGroup>
+  <Target
+    Name="Harvest"
+    DependsOnTargets="$(HarvestDependsOn)" />
+
+  <!--
+  ==================================================================================================
+  GenerateCode
+  ==================================================================================================
+  -->
+  <PropertyGroup>
+    <GenerateCodeDependsOn>
+      RefreshGeneratedFile;
+      RefreshBundleGeneratedFile
+    </GenerateCodeDependsOn>
+  </PropertyGroup>
+  <Target
+      Name="GenerateCode"
+      DependsOnTargets="$(GenerateCodeDependsOn)" />
+
+  <!--
+  ================================================================================================
+  ConvertReferences
+
+    Converts project references to HeatProject items to auto generate authoring.
+  ================================================================================================
+  -->
+  <Target
+      Name="ConvertReferences"
+      Condition=" $(EnableProjectHarvesting) and ('$(OutputType)' == 'Package' or '$(OutputType)' == 'PatchCreation' or '$(OutputType)' == 'Module') ">
+
+    <ItemGroup>
+      <_HeatProjectReference Include="@(_MSBuildProjectReferenceExistent)" Condition=" '%(_MSBuildProjectReferenceExistent.DoNotHarvest)' == '' ">
+        <DirectoryIds>%(_MSBuildProjectReferenceExistent.RefTargetDir)</DirectoryIds>
+        <ProjectOutputGroups>Binaries;Symbols;Sources;Content;Satellites;Documents</ProjectOutputGroups>
+        <ProjectName>%(_MSBuildProjectReferenceExistent.Name)</ProjectName>
+        <HeatOutput>$(IntermediateOutputPath)_%(_MSBuildProjectReferenceExistent.Filename).wxs</HeatOutput>
+      </_HeatProjectReference>
+      <HeatProject Include="@(_HeatProjectReference)" />
+    </ItemGroup>
+
+    <Error
+      Text="The following files are deprecated and should be removed from your project(s): @(Compile->'%(Identity)', ', ')"
+      Condition=" '%(Compile.GenerateComponentGroups)' != '' " />
+
+    <ItemGroup>
+      <!-- Unconditionally generate Compile items so they are always linked in. -->
+      <Compile Include="$(HarvestProjectsGeneratedFile)" />
+      <_GeneratedFiles Include="$(HarvestProjectsGeneratedFile)" />
+    </ItemGroup>
+
+  </Target>
+
+  <!--
+  ================================================================================================
+  ConvertBundleReferences
+
+    Converts project references in Bundle projects to HeatProject items to auto generate authoring.
+  ================================================================================================
+  -->
+  <Target
+    Name="ConvertBundleReferences"
+    Condition=" $(EnableProjectHarvesting) and ('$(OutputType)' == 'Bundle') ">
+
+    <ItemGroup>
+      <_HeatProjectReference Include="@(_MSBuildProjectReferenceExistent)" Condition=" '%(_MSBuildProjectReferenceExistent.DoNotHarvest)' == '' ">
+        <ProjectOutputGroups>Binaries;Symbols;Sources;Content;Satellites;Documents</ProjectOutputGroups>
+        <GenerateType>payloadgroup</GenerateType>
+        <HeatOutput>$(IntermediateOutputPath)_%(_MSBuildProjectReferenceExistent.Filename).wxs</HeatOutput>
+      </_HeatProjectReference>
+      <HeatProject Include="@(_HeatProjectReference)" />
+    </ItemGroup>
+
+    <Error
+      Text="The following files are deprecated and should be removed from your project(s): @(Compile->'%(Identity)', ', ')"
+      Condition=" '%(Compile.GenerateComponentGroups)' != '' " />
+
+    <ItemGroup>
+      <!-- Unconditionally generate Compile items so they are always linked in. -->
+      <Compile Include="$(HarvestProjectsGeneratedFile)" />
+      <_GeneratedFiles Include="$(HarvestProjectsGeneratedFile)" />
+    </ItemGroup>
+
+  </Target>
+
+  <!--
+  ================================================================================================
+  CombineHarvestProjects
+
+    Combines HeatProject and HarvestProject items together and ensures each has HeatOutput metadata.
+  ================================================================================================
+  -->
+  <Target
+      Name="CombineHarvestProjects"
+      Condition=" '@(HeatProject)' != '' or '@(HarvestProject)' != '' ">
+
+    <!-- Add default HeatOutputs for those without one specified -->
+    <CreateItem Include="@(HeatProject)" Condition= " '%(HeatProject.HeatOutput)' == '' "
+    AdditionalMetadata="HeatOutput=$(IntermediateOutputPath)_%(HeatProject.Filename).wxs">
+      <Output TaskParameter="Include" ItemName="_AllHeatProjects" />
+    </CreateItem>
+    <CreateItem Include="@(HarvestProject)" Condition= " '%(HarvestProject.HeatOutput)' == '' "
+    AdditionalMetadata="HeatOutput=$(IntermediateOutputPath)_%(HarvestProject.Filename).wxs">
+      <Output TaskParameter="Include" ItemName="_AllHeatProjects" />
+    </CreateItem>
+
+
+    <CreateItem Include="@(HeatProject)" Condition= " '%(HeatProject.HeatOutput)' != '' ">
+      <Output TaskParameter="Include" ItemName="_AllHeatProjects" />
+    </CreateItem>
+    <CreateItem Include="@(HarvestProject)" Condition= " '%(HarvestProject.HeatOutput)' != '' ">
+      <Output TaskParameter="Include" ItemName="_AllHeatProjects" />
+    </CreateItem>
+
+  </Target>
+
+  <!--
+  ================================================================================================
+  HarvestProjects
+
+    Harvests outputs of other MSBuild projects files using the VS project extension to heat.exe.
+
+    [IN]
+    @(HarvestProject)
+    @(HeatProject)
+        - The list of projects to harvest. HeatProject is provided for backward compatibility.
+          You should use HarvestProject instead.
+
+    %(HarvestProject.Transforms)
+    %(HeatProject.Transforms)
+        - XSL transforms to apply to the harvested WiX.
+
+    %(HarvestProject.ProjectOutputGroups)
+    %(HeatProjects.ProjectOutputGroups)
+        - The project output groups to harvest 
+
+    [OUT]
+    %(HeatOutput)
+        - The generated .wxs files which are added to the @(Compile) item list.
+  ================================================================================================
+  -->
+  <ItemDefinitionGroup>
+    <HeatProject>
+      <Transforms>$(HarvestProjectsTransforms)</Transforms>
+      <ProjectOutputGroups>$(HarvestProjectsProjectOutputGroups)</ProjectOutputGroups>
+      <DirectoryIds>$(HarvestProjectsDirectoryIds)</DirectoryIds>
+    </HeatProject>
+    <HarvestProject>
+      <Transforms>$(HarvestProjectsTransforms)</Transforms>
+      <ProjectOutputGroups>$(HarvestProjectsProjectOutputGroups)</ProjectOutputGroups>
+      <DirectoryIds>$(HarvestProjectsDirectoryIds)</DirectoryIds>
+    </HarvestProject>
+  </ItemDefinitionGroup>
+
+  <PropertyGroup>
+    <HarvestProjectsDependsOn>CombineHarvestProjects</HarvestProjectsDependsOn>
+  </PropertyGroup>
+  <Target Name="HarvestProjects"
+    DependsOnTargets="$(HarvestProjectsDependsOn)"
+    Inputs="@(_AllHeatProjects);%(_AllHeatProjects.Transforms);$(MSBuildAllProjects);$(ProjectPath)"
+    Outputs="@(_AllHeatProjects -> '%(HeatOutput)')"
+    Condition=" $(EnableProjectHarvesting) and ('@(HeatProject)' != '' or '@(HarvestProject)' != '') ">
+
+    <HeatProject
+      NoLogo="$(HarvestProjectsNoLogo)"
+      SuppressAllWarnings="$(HarvestProjectsSuppressAllWarnings)"
+      SuppressSpecificWarnings="$(HarvestProjectsSuppressSpecificWarnings)"
+      ToolPath="$(WixToolPath)"
+      TreatWarningsAsErrors="$(HarvestProjectsTreatWarningsAsErrors)"
+      TreatSpecificWarningsAsErrors="$(HarvestProjectsTreatSpecificWarningsAsErrors)"
+      VerboseOutput="$(HarvestProjectsVerboseOutput)"
+      AutogenerateGuids="$(HarvestProjectsAutogenerateGuids)"
+      GenerateGuidsNow="$(HarvestProjectsGenerateGuidsNow)"
+      OutputFile="%(_AllHeatProjects.HeatOutput)"
+      SuppressFragments="$(HarvestProjectsSuppressFragments)"
+      SuppressUniqueIds="$(HarvestProjectsSuppressUniqueIds)"
+      Transforms="%(_AllHeatProjects.Transforms)"
+      Project="%(_AllHeatProjects.FullPath)"
+      ProjectOutputGroups="%(_AllHeatProjects.ProjectOutputGroups)"
+      GenerateType="%(_AllHeatProjects.GenerateType)"
+      DirectoryIds="%(_AllHeatProjects.DirectoryIds)"
+      ProjectName="%(_AllHeatProjects.ProjectName)"
+      Configuration="%(_AllHeatProjects.Configuration)"
+      Platform="%(_AllHeatProjects.Platform)"
+      RunAsSeparateProcess="$(RunWixToolsOutOfProc)"
+      GenerateWixVariables="$(HarvestProjectsGenerateWixVariables)"
+      AdditionalOptions="$(HarvestProjectsAdditionalOptions)">
+
+      <Output TaskParameter="OutputFile" ItemName="Compile" />
+      <Output TaskParameter="OutputFile" ItemName="FileWrites" />
+
+    </HeatProject>
+
+  </Target>
+
+  <!--
+  ================================================================================================
+  HarvestDirectory
+
+    Harvests directories using heat.exe.
+
+    [IN]
+    @(HarvestDirectory) - The list of directories to harvest.
+    %(HarvestDirectory.Transforms) - XSL transforms to apply to the harvested WiX.
+    %(HarvestDirectory.ComponentGroupName) -  The name of the ComponentGroup to create.
+    %(HarvestDirectory.DirectoryRefId) - The ID of the directory to reference instead of TARGETDIR.
+    %(HarvestDirectory.KeepEmptyDirectories) - Whether to create Directory entries for empty directories.
+    %(HarvestDirectory.PreprocessorVariable) - Substitute SourceDir for another variable name (ex: var.Dir).
+    %(HarvestDirectory.SuppressCom) - Suppress COM elements.
+    %(HarvestDirectory.SuppressRootDirectory) - Suppress a Directory element for the root directory.
+    $(HarvestDirectory.SuppressRegistry) - Suppress registry harvesting.
+
+    [OUT]
+    $(IntermediateOutputPath)_%(HarvestDirectory.ComponentGroupName)_dir.wxs
+        - The generated .wxs files which are added to the @(Compile) item list.
+  ================================================================================================
+  -->
+
+  <ItemDefinitionGroup>
+    <HarvestDirectory>
+      <Transforms>$(HarvestDirectoryTransforms)</Transforms>
+      <ComponentGroupName>$(HarvestDirectoryComponentGroupName)</ComponentGroupName>
+      <DirectoryRefId>$(HarvestDirectoryDirectoryRefId)</DirectoryRefId>
+      <KeepEmptyDirectories>$(HarvestDirectoryKeepEmptyDirectories)</KeepEmptyDirectories>
+      <PreprocessorVariable>$(HarvestDirectoryPreprocessorVariable)</PreprocessorVariable>
+      <SuppressCom>$(HarvestDirectorySuppressCom)</SuppressCom>
+      <SuppressRootDirectory>$(HarvestDirectorySuppressRootDirectory)</SuppressRootDirectory>
+      <SuppressRegistry>$(HarvestDirectorySuppressRegistry)</SuppressRegistry>
+    </HarvestDirectory>
+  </ItemDefinitionGroup>
+
+  <PropertyGroup>
+    <HarvestDirectoryDependsOn>
+      GetHarvestDirectoryContent
+    </HarvestDirectoryDependsOn>
+  </PropertyGroup>
+
+  <!-- Creates items to include content since wildcards will not work in Target/@Inputs. -->
+  <Target Name="GetHarvestDirectoryContent">
+    <CreateItem Include="@(HarvestDirectory->'%(FullPath)\**\*')">
+      <Output TaskParameter="Include" ItemName="_HarvestDirectoryContent" />
+    </CreateItem>
+  </Target>
+
+  <Target Name="HarvestDirectory"
+    DependsOnTargets="$(HarvestDirectoryDependsOn)"
+    Inputs="@(_HarvestDirectoryContent);%(HarvestDirectory.Transforms)"
+    Outputs="$(IntermediateOutputPath)_%(HarvestDirectory.ComponentGroupName)_dir.wxs"
+    Condition=" '@(HarvestDirectory)' != '' ">
+
+    <HeatDirectory
+      NoLogo="$(HarvestDirectoryNoLogo)"
+      SuppressAllWarnings="$(HarvestDirectorySuppressAllWarnings)"
+      SuppressSpecificWarnings="$(HarvestDirectorySuppressSpecificWarnings)"
+      ToolPath="$(WixToolPath)"
+      TreatWarningsAsErrors="$(HarvestDirectoryTreatWarningsAsErrors)"
+      TreatSpecificWarningsAsErrors="$(HarvestDirectoryTreatSpecificWarningsAsErrors)"
+      VerboseOutput="$(HarvestDirectoryVerboseOutput)"
+      AutogenerateGuids="$(HarvestDirectoryAutogenerateGuids)"
+      GenerateGuidsNow="$(HarvestDirectoryGenerateGuidsNow)"
+      OutputFile="$(IntermediateOutputPath)_%(HarvestDirectory.ComponentGroupName)_dir.wxs"
+      SuppressFragments="$(HarvestDirectorySuppressFragments)"
+      SuppressUniqueIds="$(HarvestDirectorySuppressUniqueIds)"
+      Transforms="%(HarvestDirectory.Transforms)"
+      Directory="@(HarvestDirectory)"
+      ComponentGroupName="%(HarvestDirectory.ComponentGroupName)"
+      DirectoryRefId="%(HarvestDirectory.DirectoryRefId)"
+      KeepEmptyDirectories="%(HarvestDirectory.KeepEmptyDirectories)"
+      PreprocessorVariable="%(HarvestDirectory.PreprocessorVariable)"
+      RunAsSeparateProcess="$(RunWixToolsOutOfProc)"
+      SuppressCom="%(HarvestDirectory.SuppressCom)"
+      SuppressRootDirectory="%(HarvestDirectory.SuppressRootDirectory)"
+      SuppressRegistry="%(HarvestDirectory.SuppressRegistry)"
+      AdditionalOptions="$(HarvestDirectoryAdditionalOptions)">
+
+      <Output TaskParameter="OutputFile" ItemName="Compile" />
+      <Output TaskParameter="OutputFile" ItemName="FileWrites" />
+
+    </HeatDirectory>
+
+  </Target>
+
+  <!--
+  ================================================================================================
+  HarvestFile
+
+    Harvests files of different types using heat.exe. This can harvest registry from
+    self-registering files, files with typelibs, and more.
+
+    [IN]
+    @(HarvestFile) - The list of files to harvest.
+    %(HarvestFile.Transforms) - XSL transforms to apply to the harvested WiX.
+    %(HarvestFile.ComponentGroupName) - The name of the ComponentGroup to create.
+    %(HarvestFile.DirectoryRefId) - The ID of the directory to reference instead of TARGETDIR.
+    %(HarvestFile.PreprocessorVariable) - Substitute SourceDir for another variable name (ex: var.Dir).
+    %(HarvestFile.SuppressCom) - Suppress COM elements.
+    %(HarvestFile.SuppressRootDirectory) - Suppress a Directory element for the root directory.
+    $(HarvestFile.SuppressRegistry) - Suppress registry harvesting.
+
+    [OUT]
+    $(IntermediateOutputPath)_%(HarvestFile.Filename)_file.wxs
+        - The generated .wxs files which are added to the @(Compile) item list.
+  ================================================================================================
+  -->
+
+  <ItemDefinitionGroup>
+    <HarvestFile>
+      <Transforms>$(HarvestFileTransforms)</Transforms>
+      <ComponentGroupName>$(HarvestFileComponentGroupName)</ComponentGroupName>
+      <DirectoryRefId>$(HarvestFileDirectoryRefId)</DirectoryRefId>
+      <PreprocessorVariable>$(HarvestFilePreprocessorVariable)</PreprocessorVariable>
+      <SuppressCom>$(HarvestFileSuppressCom)</SuppressCom>
+      <SuppressRegistry>$(HarvestFileSuppressRegistry)</SuppressRegistry>
+      <SuppressRootDirectory>$(HarvestFileSuppressRootDirectory)</SuppressRootDirectory>
+    </HarvestFile>
+  </ItemDefinitionGroup>
+
+  <PropertyGroup>
+    <HarvestFileDependsOn></HarvestFileDependsOn>
+  </PropertyGroup>
+  <Target Name="HarvestFile"
+    DependsOnTargets="$(HarvestFileDependsOn)"
+    Inputs="@(HarvestFile);%(HarvestFile.Transforms)"
+    Outputs="$(IntermediateOutputPath)_%(HarvestFile.Filename)_file.wxs"
+    Condition=" '@(HarvestFile)' != '' ">
+
+    <HeatFile
+      NoLogo="$(HarvestFileNoLogo)"
+      SuppressAllWarnings="$(HarvestFileSuppressAllWarnings)"
+      SuppressSpecificWarnings="$(HarvestFileSuppressSpecificWarnings)"
+      ToolPath="$(WixToolPath)"
+      TreatWarningsAsErrors="$(HarvestFileTreatWarningsAsErrors)"
+      TreatSpecificWarningsAsErrors="$(HarvestFileTreatSpecificWarningsAsErrors)"
+      VerboseOutput="$(HarvestFileVerboseOutput)"
+      AutogenerateGuids="$(HarvestFileAutogenerateGuids)"
+      GenerateGuidsNow="$(HarvestFileGenerateGuidsNow)"
+      OutputFile="$(IntermediateOutputPath)_%(HarvestFile.Filename)_file.wxs"
+      SuppressFragments="$(HarvestFileSuppressFragments)"
+      SuppressUniqueIds="$(HarvestFileSuppressUniqueIds)"
+      Transforms="%(HarvestFile.Transforms)"
+      File="@(HarvestFile)"
+      ComponentGroupName="%(HarvestFile.ComponentGroupName)"
+      DirectoryRefId="%(HarvestFile.DirectoryRefId)"
+      PreprocessorVariable="%(HarvestFile.PreprocessorVariable)"
+      RunAsSeparateProcess="$(RunWixToolsOutOfProc)"
+      SuppressCom="%(HarvestFile.SuppressCom)"
+      SuppressRegistry="%(HarvestFile.SuppressRegistry)"
+      SuppressRootDirectory="%(HarvestFile.SuppressRootDirectory)"
+      AdditionalOptions="$(HarvestFileAdditionalOptions)">
+
+      <Output TaskParameter="OutputFile" ItemName="Compile" />
+      <Output TaskParameter="OutputFile" ItemName="FileWrites" />
+
+    </HeatFile>
+
+  </Target>
+
+  <!--
+  ================================================================================================
+  RefreshGeneratedFile
+
+    Generates code based on metadata defined in project references.
+
+    [IN]
+    @(_MSBuildResolvedProjectReferencePaths) - The list of MSBuildable project references.
+
+    [OUT]
+    @(_GeneratedFiles) - The generated source file.
+  ================================================================================================
+  -->
+  <PropertyGroup>
+    <RefreshGeneratedFileDependsOn></RefreshGeneratedFileDependsOn>
+  </PropertyGroup>
+  <Target Name="RefreshGeneratedFile"
+    DependsOnTargets="$(RefreshGeneratedFileDependsOn)"
+    Inputs="@(_MSBuildResolvedProjectReferencePaths);@(Compile);$(ProjectPath)"
+    Outputs="@(_GeneratedFiles)"
+    Condition=" $(EnableProjectHarvesting) and ('$(OutputType)' == 'Package' or '$(OutputType)' == 'PatchCreation' or '$(OutputType)' == 'Module') and '@(_GeneratedFiles)' != '' ">
+
+    <RefreshGeneratedFile
+      GeneratedFiles="@(_GeneratedFiles)"
+      ProjectReferencePaths="@(_MSBuildResolvedProjectReferencePaths)" />
+
+  </Target>
+
+  <!--
+  ================================================================================================
+  RefreshBundleGeneratedFile
+
+    Generates code for bundle projects based on metadata defined in project references.
+
+    [IN]
+    @(_MSBuildResolvedProjectReferencePaths) - The list of MSBuildable project references.
+
+    [OUT]
+    @(_GeneratedFiles) - The generated source file.
+  ================================================================================================
+  -->
+  <PropertyGroup>
+    <RefreshBundleGeneratedFileDependsOn></RefreshBundleGeneratedFileDependsOn>
+  </PropertyGroup>
+  <Target Name="RefreshBundleGeneratedFile"
+    DependsOnTargets="$(RefreshBundleGeneratedFileDependsOn)"
+    Inputs="@(_MSBuildResolvedProjectReferencePaths);@(Compile);$(ProjectPath)"
+    Outputs="@(_GeneratedFiles)"
+    Condition=" $(EnableProjectHarvesting) and ('$(OutputType)' == 'Bundle' and '@(_GeneratedFiles)' != '') ">
+
+    <RefreshBundleGeneratedFile
+      GeneratedFiles="@(_GeneratedFiles)"
+      ProjectReferencePaths="@(_MSBuildResolvedProjectReferencePaths)" />
+  </Target>
+
+</Project>
diff --git a/src/WixToolset.BuildTasks/wix.signing.targets b/src/WixToolset.BuildTasks/wix.signing.targets
new file mode 100644
index 00000000..6351cc8b
--- /dev/null
+++ b/src/WixToolset.BuildTasks/wix.signing.targets
@@ -0,0 +1,378 @@
+<?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 xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+
+  <!-- These properties can be overridden to support non-default installations. -->
+  <PropertyGroup>
+    <WixTargetsPath Condition=" '$(WixTargetsPath)' == '' ">$(MSBuildThisFileFullPath)</WixTargetsPath>
+    <WixTasksPath Condition=" '$(WixTasksPath)' == '' ">$(WixTargetsPath)WixTasks.dll</WixTasksPath>
+
+    <SignedFile Condition=" '$(SignedFile)' == '' ">$(MSBuildProjectFile).Signed.txt</SignedFile>
+  </PropertyGroup>
+
+  <UsingTask TaskName="Insignia" AssemblyFile="$(WixTasksPath)" />
+
+  <!-- Default Inscribe properties. -->
+  <PropertyGroup>
+    <InscribeNoLogo Condition=" '$(InscribeNoLogo)' == '' ">$(NoLogo)</InscribeNoLogo>
+    <InscribeSuppressAllWarnings Condition=" '$(InscribeSuppressAllWarnings)' == '' ">$(SuppressAllWarnings)</InscribeSuppressAllWarnings>
+    <InscribeSuppressSpecificWarnings Condition=" '$(InscribeSuppressSpecificWarnings)' == '' ">$(SuppressSpecificWarnings)</InscribeSuppressSpecificWarnings>
+    <InscribeTreatWarningsAsErrors Condition=" '$(InscribeTreatWarningsAsErrors)' == '' ">$(TreatWarningsAsErrors)</InscribeTreatWarningsAsErrors>
+    <InscribeTreatSpecificWarningsAsErrors Condition=" '$(InscribeTreatSpecificWarningsAsErrors)' == '' ">$(TreatSpecificWarningsAsErrors)</InscribeTreatSpecificWarningsAsErrors>
+    <InscribeVerboseOutput Condition=" '$(InscribeVerboseOutput)' == '' ">$(VerboseOutput)</InscribeVerboseOutput>
+  </PropertyGroup>
+
+  <!--
+  ==================================================================================================
+  Signing
+  ==================================================================================================
+  -->
+  <PropertyGroup>
+    <InternalSignDependsOn Condition=" '$(OutputType)' == 'Module' ">
+      GetMsmsToSign;
+      InternalSignMsm;
+    </InternalSignDependsOn>
+    <InternalSignDependsOn Condition=" '$(OutputType)' == 'Package' ">
+      GetCabsToSign;
+      GetMsiToSign;
+      InternalSignCabs;
+      InscribeMsi;
+      InternalSignMsi;
+    </InternalSignDependsOn>
+    <InternalSignDependsOn Condition=" '$(OutputType)' == 'Bundle' ">
+      GetContainersToSign;
+      InternalSignContainers;
+      InscribeBundleEngine;
+      InternalSignBundleEngine;
+      InscribeBundle;
+      InternalSignBundle;
+    </InternalSignDependsOn>
+
+    <SigningDependsOn>
+      CompileAndLink;
+      BeforeSigning;
+      $(InternalSignDependsOn);
+      AfterSigning
+    </SigningDependsOn>
+  </PropertyGroup>
+  <Target
+    Name="Signing"
+    DependsOnTargets="$(SigningDependsOn)"
+    Inputs="@(SignTargetPath)"
+    Outputs="$(IntermediateOutputPath)$(SignedFile)"
+    Condition=" '@(SignTargetPath)' != '' ">
+
+    <CreateItem Include="$(IntermediateOutputPath)$(SignedFile)">
+      <Output TaskParameter="Include" ItemName="FileWrites" />
+    </CreateItem>
+
+    <WriteLinesToFile
+        File="$(IntermediateOutputPath)$(SignedFile)"
+        Lines="^$(MSBuildProjectFullPath);@(SignMsm);@(SignCabs);@(SignMsi);@(SignContainers);@(SignBundleEngine);@(SignBundle)"
+        Overwrite="true" />
+  </Target>
+
+  <!-- Internal targets so correct signing targets are called. -->
+  <Target
+      Name="GetMsmsToSign"
+      Inputs="@(SignTargetPath)"
+      Outputs="$(IntermediateOutputPath)$(SignedFile)">
+    <CreateItem Include="@(SignTargetPath)">
+      <Output TaskParameter="Include" ItemName="SignMsm" />
+      <Output TaskParameter="Include" ItemName="FileWrites" />
+    </CreateItem>
+  </Target>
+
+  <Target
+    Name="InternalSignMsm"
+    DependsOnTargets="SignMsm"
+    Condition=" '@(SignMsm)' != '' " />
+
+  <Target
+      Name="GetCabsToSign"
+      Inputs="@(SignTargetPath)"
+      Outputs="$(IntermediateOutputPath)$(SignedFile)">
+    <GetCabList Database="%(SignTargetPath.FullPath)">
+      <Output TaskParameter="CabList" ItemName="SignCabs" />
+      <Output TaskParameter="CabList" ItemName="FileWrites" />
+    </GetCabList>
+  </Target>
+
+  <Target
+    Name="InternalSignCabs"
+    DependsOnTargets="SignCabs"
+    Condition=" '@(SignCabs)' != '' " />
+
+  <Target
+      Name="GetMsiToSign"
+      Inputs="@(SignTargetPath)"
+      Outputs="$(IntermediateOutputPath)$(SignedFile)">
+    <CreateItemAvoidingInference InputProperties="@(SignTargetPath)">
+      <Output TaskParameter="OuputItems" ItemName="SignMsi" />
+      <Output TaskParameter="OuputItems" ItemName="FileWrites" />
+    </CreateItemAvoidingInference>
+  </Target>
+
+  <Target
+    Name="InternalSignMsi"
+    DependsOnTargets="SignMsi"
+    Inputs="@(SignTargetPath)"
+    Outputs="$(IntermediateOutputPath)$(SignedFile)"
+    Condition=" '@(SignMsi)' != '' " />
+
+  <Target
+      Name="GetContainersToSign"
+      Inputs="@(SignTargetPath)"
+      Outputs="$(IntermediateOutputPath)$(SignedFile)">
+    <!-- TODO: implement signing detached containers -->
+  </Target>
+
+  <Target
+    Name="InternalSignContainers"
+    DependsOnTargets="SignContainers"
+    Condition=" '@(SignContainers)' != '' " />
+
+  <Target
+    Name="InternalSignBundleEngine"
+    DependsOnTargets="SignBundleEngine"
+    Condition=" '@(SignBundleEngine)' != '' " />
+
+  <Target
+    Name="InternalSignBundle"
+    DependsOnTargets="SignBundle"
+    Condition=" '@(SignBundle)' != '' " />
+
+  <!--
+  ================================================================================================
+  InscribeMsi
+
+    To be called after signing an MSI's cabs - inscribes an MSI with the digital signature of its
+      external cabs.
+
+    [IN/OUT]
+    @(SignTargetPath) - The database file to inscribe - database file will be modified in-place.
+
+    [OUT]
+    @(SignMsi) - The database file to sign.
+  ================================================================================================
+  -->
+  <PropertyGroup>
+    <InscribeMsiDependsOn>
+      PrepareForBuild;
+      ResolveWixExtensionReferences;
+      CompileAndLink;
+      InternalSignCabs
+    </InscribeMsiDependsOn>
+  </PropertyGroup>
+  <Target
+      Name="InscribeMsi"
+      DependsOnTargets="$(InscribeMsiDependsOn)"
+      Inputs="@(SignTargetPath)"
+      Outputs="$(IntermediateOutputPath)$(SignedFile)"
+      Condition=" '@(SignCabs)' != '' ">
+
+    <Insignia
+        DatabaseFile="%(SignTargetPath.FullPath)"
+        OutputFile="%(SignTargetPath.FullPath)"
+        ToolPath="$(WixToolPath)"
+        NoLogo="$(InscribeNoLogo)"
+        RunAsSeparateProcess="$(RunWixToolsOutOfProc)"
+        SuppressAllWarnings="$(InscribeSuppressAllWarnings)"
+        SuppressSpecificWarnings="$(InscribeSuppressSpecificWarnings)"
+        TreatWarningsAsErrors="$(InscribeTreatWarningsAsErrors)"
+        TreatSpecificWarningsAsErrors="$(InscribeTreatSpecificWarningsAsErrors)"
+        VerboseOutput="$(InscribeVerboseOutput)"
+        AdditionalOptions="$(InscribeAdditionalOptions)" />
+  </Target>
+
+  <!--
+  ================================================================================================
+  InscribeBundleEngine
+
+    To be called after signing a bundle's detached containers. Also removes attached container
+    so engine can be signed without attached container.
+
+    [IN]
+    @(SignTargetPath) - The bundle to inscribe.
+
+    [OUT]
+    @(SignBundleEngine) - The bundle engine file to be signed.
+  ================================================================================================
+  -->
+  <PropertyGroup>
+    <InscribeBundleEngineDependsOn>
+      PrepareForBuild;
+      ResolveWixExtensionReferences;
+      CompileAndLink;
+      InternalSignContainers
+    </InscribeBundleEngineDependsOn>
+  </PropertyGroup>
+  <Target
+      Name="InscribeBundleEngine"
+      DependsOnTargets="$(InscribeBundleEngineDependsOn)"
+      Inputs="@(SignTargetPath)"
+      Outputs="$(IntermediateOutputPath)$(SignedFile)">
+
+    <Insignia
+        BundleFile="@(SignTargetPath)"
+        OutputFile="$(IntermediateOutputPath)%(SignTargetPath.Filename)%(SignTargetPath.Extension)"
+        ToolPath="$(WixToolPath)"
+        NoLogo="$(InscribeNoLogo)"
+        RunAsSeparateProcess="$(RunWixToolsOutOfProc)"
+        SuppressAllWarnings="$(InscribeSuppressAllWarnings)"
+        SuppressSpecificWarnings="$(InscribeSuppressSpecificWarnings)"
+        TreatWarningsAsErrors="$(InscribeTreatWarningsAsErrors)"
+        TreatSpecificWarningsAsErrors="$(InscribeTreatSpecificWarningsAsErrors)"
+        VerboseOutput="$(InscribeVerboseOutput)"
+        AdditionalOptions="$(InscribeAdditionalOptions)">
+      <Output TaskParameter="Output" ItemName="SignBundleEngine" />
+    </Insignia>
+
+    <!-- Explicitly add output to FileWrites to ensure even when the target is up to date. -->
+    <CreateItem Include="$(IntermediateOutputPath)%(SignTargetPath.Filename)%(SignTargetPath.Extension)">
+      <Output TaskParameter="Include" ItemName="FileWrites" />
+    </CreateItem>
+
+  </Target>
+
+  <!--
+  ================================================================================================
+  InscribeBundle
+
+    To be called after signing the bundle engine to reattach the attached container.
+
+    [IN]
+    @(Inscribe) - The bundle to inscribe.
+
+    [OUT]
+    @(SignBundle) - The bundle engine file to be signed.
+  ================================================================================================
+  -->
+  <PropertyGroup>
+    <InscribeBundleDependsOn>
+      PrepareForBuild;
+      ResolveWixExtensionReferences;
+      CompileAndLink;
+      InternalSignBundleEngine
+    </InscribeBundleDependsOn>
+  </PropertyGroup>
+  <Target
+      Name="InscribeBundle"
+      DependsOnTargets="$(InscribeBundleDependsOn)"
+      Inputs="@(SignTargetPath)"
+      Outputs="$(IntermediateOutputPath)$(SignedFile)">
+
+    <Insignia
+        BundleFile="@(SignBundleEngine)"
+        OriginalBundleFile="@(SignTargetPath)"
+        OutputFile="@(SignTargetPath)"
+        ToolPath="$(WixToolPath)"
+        NoLogo="$(InscribeNoLogo)"
+        RunAsSeparateProcess="$(RunWixToolsOutOfProc)"
+        SuppressAllWarnings="$(InscribeSuppressAllWarnings)"
+        SuppressSpecificWarnings="$(InscribeSuppressSpecificWarnings)"
+        TreatWarningsAsErrors="$(InscribeTreatWarningsAsErrors)"
+        TreatSpecificWarningsAsErrors="$(InscribeTreatSpecificWarningsAsErrors)"
+        VerboseOutput="$(InscribeVerboseOutput)"
+        AdditionalOptions="$(InscribeAdditionalOptions)">
+      <Output TaskParameter="Output" ItemName="SignBundle" />
+      <Output TaskParameter="Output" ItemName="FileWrites" />
+    </Insignia>
+  </Target>
+
+  <!--
+  ==================================================================================================
+  BeforeSigning
+
+    Redefine this target in your project in order to run tasks just before all signing tasks.
+  ==================================================================================================
+  -->
+  <Target Name="BeforeSigning" />
+
+  <!--
+  ==================================================================================================
+  SignMsm
+
+    Redefine this target in your project in order to sign merge modules.
+
+    [IN]
+    @(SignMsm) - merge module files to sign.
+  ==================================================================================================
+  -->
+  <Target Name="SignMsm" />
+
+  <!--
+  ==================================================================================================
+  SignCabs
+
+    Redefine this target in your project in order to sign the cabs of your database.
+
+    [IN]
+    @(SignCabs) - cabinet files to sign.
+  ==================================================================================================
+  -->
+  <Target Name="SignCabs" />
+
+  <!--
+  ==================================================================================================
+  SignMsi
+
+    Redefine this target in your project in order to sign your database, after it has been inscribed
+    with the signatures of your signed cabs.
+
+    [IN]
+    @(SignMsi) - database files to sign.
+  ==================================================================================================
+  -->
+  <Target Name="SignMsi" />
+
+  <!--
+  ==================================================================================================
+  SignContainers
+
+    Redefine this target in your project in order to sign your bundle's detached containers.
+
+    [IN]
+    @(SignContainers) - detached container files to sign.
+  ==================================================================================================
+  -->
+  <Target Name="SignContainers" />
+
+  <!--
+  ==================================================================================================
+  SignBundleEngine
+
+    Redefine this target in your project in order to sign your bundle, after it has been inscribed
+    with the signatures of your signed containers.
+
+    [IN]
+    @(SignBundleEngine) - bundle engine file to sign.
+  ==================================================================================================
+  -->
+  <Target Name="SignBundleEngine" />
+
+  <!--
+  ==================================================================================================
+  SignBundle
+
+    Redefine this target in your project in order to sign your bundle, after the attached container
+    is reattached.
+
+    [IN]
+    @(SignBundle) - bundle file to sign.
+  ==================================================================================================
+  -->
+  <Target Name="SignBundle" />
+
+  <!--
+  ==================================================================================================
+  AfterSigning
+
+    Redefine this target in your project in order to run tasks just after all signing tasks.
+  ==================================================================================================
+  -->
+  <Target Name="AfterSigning" />
+
+</Project>
diff --git a/src/WixToolset.BuildTasks/wix.targets b/src/WixToolset.BuildTasks/wix.targets
new file mode 100644
index 00000000..eadd33ec
--- /dev/null
+++ b/src/WixToolset.BuildTasks/wix.targets
@@ -0,0 +1,1353 @@
+<?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 xmlns="http://schemas.microsoft.com/developer/msbuild/2003" InitialTargets="_CheckRequiredProperties" DefaultTargets="Build">
+  <PropertyGroup>
+    <WixTargetsImported>true</WixTargetsImported>
+  </PropertyGroup>
+
+  <!--
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  Extension Points
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  -->
+
+  <!-- Allow a user-customized targets files to be used as part of the build. -->
+  <Import Project="$(CustomBeforeWixTargets)" Condition=" '$(CustomBeforeWixTargets)' != '' and Exists('$(CustomBeforeWixTargets)')" />
+
+  <!-- These properties can be overridden to support non-default installations. -->
+  <PropertyGroup>
+    <WixBinDir Condition=" '$(WixBinDir)' == ''">$(MSBuildThisFileDirectory)</WixBinDir>
+    <WixTasksPath Condition=" '$(WixTasksPath)' == '' ">$(WixBinDir)WixToolset.BuildTasks.dll</WixTasksPath>
+    <WixHarvestTargetsPath Condition=" '$(WixHarvestTargetsPath)' == '' ">$(WixBinDir)wix.harvest.targets</WixHarvestTargetsPath>
+    <WixSigningTargetsPath Condition=" '$(WixSigningTargetsPath)' == '' ">$(WixBinDir)wix.signing.targets</WixSigningTargetsPath>
+    <LuxTargetsPath Condition=" '$(LuxTargetsPath)' == '' ">$(WixBinDir)lux.targets</LuxTargetsPath>
+    <LuxTasksPath Condition=" '$(LuxTasksPath)' == '' ">$(WixBinDir)LuxTasks.dll</LuxTasksPath>
+  </PropertyGroup>
+
+  <!-- This makes the project files a dependency of all targets so that things rebuild if they change -->
+  <PropertyGroup>
+    <MSBuildAllProjects>$(MSBuildAllProjects);$(MSBuildThisFileFullPath)</MSBuildAllProjects>
+    <MSBuildAllProjects Condition="Exists('$(WixHarvestTargetsPath)')">$(MSBuildAllProjects);$(WixHarvestTargetsPath)</MSBuildAllProjects>
+    <MSBuildAllProjects Condition="Exists('$(WixSigningTargetsPath)')">$(MSBuildAllProjects);$(WixSigningTargetsPath)</MSBuildAllProjects>
+    <MSBuildAllProjects Condition="Exists('$(LuxTargetsPath)')">$(MSBuildAllProjects);$(LuxTargetsPath)</MSBuildAllProjects>
+    <MSBuildAllProjects Condition="Exists('$(CustomBeforeWixTargets)')">$(MSBuildAllProjects);$(CustomBeforeWixTargets)</MSBuildAllProjects>
+    <MSBuildAllProjects Condition="Exists('$(CustomAfterWixTargets)')">$(MSBuildAllProjects);$(CustomAfterWixTargets)</MSBuildAllProjects>
+  </PropertyGroup>
+
+  <!--
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  Declarations for Microsoft.Common.targets
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  -->
+
+  <PropertyGroup>
+    <DefaultLanguageSourceExtension>.wxs</DefaultLanguageSourceExtension>
+    <Language>wix</Language>
+    <TargetRuntime>Managed</TargetRuntime>
+
+    <!-- Use OutputName to set the AssemblyName for Microsoft.Common.targets -->
+    <OutputName Condition=" '$(OutputName)'=='' ">$(MSBuildProjectName)</OutputName>
+    <AssemblyName>$(OutputName)</AssemblyName>
+
+    <!-- Default the OutputType to a known WiX toolset TYPE.  -->
+    <_OriginalOutputType>$(OutputType)</_OriginalOutputType>
+    <OutputType Condition=" '$(OutputType)' == '' ">Package</OutputType>
+  </PropertyGroup>
+
+  <!--
+  IDE Macros available from both integrated builds and from command line builds.
+  The following properties are 'macros' that are available via IDE for pre and post build steps.
+  All of them should be added to WixBuildMacroCollection to ensure that they are shown in the UI.
+  -->
+  <PropertyGroup>
+    <TargetExt Condition=" '$(OutputType)' == 'Package' ">.msi</TargetExt>
+    <TargetExt Condition=" '$(OutputType)' == 'Module' ">.msm</TargetExt>
+    <TargetExt Condition=" '$(OutputType)' == 'PatchCreation' ">.pcp</TargetExt>
+    <TargetExt Condition=" '$(OutputType)' == 'Library' ">.wixlib</TargetExt>
+    <TargetExt Condition=" '$(OutputType)' == 'Bundle' ">.exe</TargetExt>
+  </PropertyGroup>
+
+  <!-- Provide the correct output name for the .wixpdb -->
+  <ItemGroup Condition="'$(_DebugSymbolsProduced)' == 'true'">
+    <_DebugSymbolsIntermediatePath Include="$(PdbOutputDir)$(TargetPdbName)" Condition=" '@(_DebugSymbolsIntermediatePath)' == '' " />
+  </ItemGroup>
+
+  <Import Project="$(MSBuildToolsPath)\Microsoft.Common.targets" />
+
+  <PropertyGroup>
+    <!-- Default pdb output path to the intermediate output directory -->
+    <PdbOutputDir Condition=" '$(PdbOutputDir)'=='' ">$(IntermediateOutputPath)</PdbOutputDir>
+    <PdbOutputDir Condition=" '$(PdbOutputDir)' != '' and !HasTrailingSlash('$(PdbOutputDir)') ">$(PdbOutputDir)\</PdbOutputDir>
+
+    <!-- Example, C:\MyProjects\MyProject\bin\debug\ -->
+    <TargetPdbDir Condition=" '$(PdbOutputDir)'!='' ">$([System.IO.Path]::GetFullPath(`$([System.IO.Path]::Combine(`$(MSBuildProjectDirectory)`, `$(PdbOutputDir)`))`))</TargetPdbDir>
+
+    <!-- Example, MySetup.wixpdb" -->
+    <TargetPdbName Condition=" '$(TargetPdbName)' == '' ">$(TargetName).wixpdb</TargetPdbName>
+
+    <!-- Example, C:\MyProjects\MyProject\bin\debug\MyPackage.wixpdb -->
+    <TargetPdbPath Condition=" '$(TargetPdbPath)' == '' ">$(TargetPdbDir)$(TargetPdbName)</TargetPdbPath>
+  </PropertyGroup>
+
+  <!--
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  Property Declarations
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  -->
+
+  <!-- These tasks can be used as general-purpose build tasks. -->
+  <UsingTask TaskName="Candle" AssemblyFile="$(WixTasksPath)" />
+  <UsingTask TaskName="DoIt" AssemblyFile="$(WixTasksPath)" />
+  <UsingTask TaskName="Lit" AssemblyFile="$(WixTasksPath)" />
+  <UsingTask TaskName="Light" AssemblyFile="$(WixTasksPath)" />
+  <UsingTask TaskName="Torch" AssemblyFile="$(WixTasksPath)" />
+
+  <!-- These tasks are specific to the build process defined in this file, and are not considered general-purpose build tasks. -->
+  <UsingTask TaskName="CreateItemAvoidingInference" AssemblyFile="$(WixTasksPath)" />
+  <UsingTask TaskName="CreateProjectReferenceDefineConstants" AssemblyFile="$(WixTasksPath)" />
+  <UsingTask TaskName="WixAssignCulture" AssemblyFile="$(WixTasksPath)" />
+  <UsingTask TaskName="ResolveWixReferences" AssemblyFile="$(WixTasksPath)"/>
+  <UsingTask TaskName="ReplaceString" AssemblyFile="$(WixTasksPath)"/>
+  <UsingTask TaskName="GetCabList" AssemblyFile="$(WixTasksPath)" />
+  <UsingTask TaskName="GetLooseFileList" AssemblyFile="$(WixTasksPath)" />
+  <UsingTask TaskName="GenerateCompileWithObjectPath" AssemblyFile="$(WixTasksPath)"/>
+
+  <!-- WiX tools are 32bit EXEs, so run them out-of-proc when MSBuild is not 32bit. -->
+  <PropertyGroup>
+    <RunWixToolsOutOfProc Condition=" '$(PROCESSOR_ARCHITECTURE)'!='x86' ">true</RunWixToolsOutOfProc>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <BindContentsFile Condition=" '$(BindContentsFile)' == '' ">$(MSBuildProjectFile).BindContentsFileList.txt</BindContentsFile>
+    <BindOutputsFile Condition=" '$(BindOutputsFile)' == '' ">$(MSBuildProjectFile).BindOutputsFileList.txt</BindOutputsFile>
+    <BindBuiltOutputsFile Condition=" '$(BindBuiltOutputsFile)' == '' ">$(MSBuildProjectFile).BindBuiltOutputsFileList.txt</BindBuiltOutputsFile>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <CabinetCachePath Condition=" '$(CabinetCachePath)'=='' and '$(ReuseCabinetCache)'=='true' ">$(IntermediateOutputPath)cabcache\</CabinetCachePath>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <WixToolDir Condition=" '$(WixToolDir)' == ''">$(WixBinDir)</WixToolDir>
+    <WixExtDir Condition=" '$(WixExtDir)' == ''">$(WixToolDir)</WixExtDir>
+  </PropertyGroup>
+
+  <!--
+  Set the SignTargetPath item directly when output is a Bundle. The AssignCultures target
+  sets SignTargetPath item for other output types based on the cultures provided.
+  -->
+  <ItemGroup>
+    <SignTargetPath Include="$(TargetPath)" Condition=" '$(OutputType)' == 'Bundle' AND '$(SignOutput)' == 'true' AND '$(SuppressLayout)' != 'true' " />
+  </ItemGroup>
+
+  <!--
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  Default Compiler, Linker, and Librarian Property Declarations
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  -->
+
+  <!-- If WixExtension was passed in via the command line, then convert it to an ItemGroup -->
+  <ItemGroup>
+    <WixExtension Include="$(WixExtension)"  Condition=" '$(WixExtension)' != '' " />
+  </ItemGroup>
+
+  <!-- Defaut Compiler properties. -->
+  <PropertyGroup>
+    <CompilerNoLogo Condition=" '$(CompilerNoLogo)' == '' ">$(NoLogo)</CompilerNoLogo>
+    <CompilerSuppressAllWarnings Condition=" '$(CompilerSuppressAllWarnings)' == '' ">$(SuppressAllWarnings)</CompilerSuppressAllWarnings>
+    <CompilerSuppressSpecificWarnings Condition=" '$(CompilerSuppressSpecificWarnings)' == '' ">$(SuppressSpecificWarnings)</CompilerSuppressSpecificWarnings>
+    <CompilerTreatWarningsAsErrors Condition=" '$(CompilerTreatWarningsAsErrors)' == '' ">$(TreatWarningsAsErrors)</CompilerTreatWarningsAsErrors>
+    <CompilerTreatSpecificWarningsAsErrors Condition=" '$(CompilerTreatSpecificWarningsAsErrors)' == '' ">$(TreatSpecificWarningsAsErrors)</CompilerTreatSpecificWarningsAsErrors>
+    <CompilerVerboseOutput Condition=" '$(CompilerVerboseOutput)' == '' ">$(VerboseOutput)</CompilerVerboseOutput>
+    <!-- TODO: This probably doesn't work any longer since Platform won't be defined until Microsoft.Common.targets is included -->
+    <InstallerPlatform Condition=" '$(InstallerPlatform)' == '' and '$(Platform)' != 'AnyCPU' and '$(Platform)' != 'Any CPU' ">$(Platform)</InstallerPlatform>
+  </PropertyGroup>
+
+  <!-- Default Lib properties. -->
+  <PropertyGroup>
+    <LibNoLogo Condition=" '$(LibNoLogo)' == '' ">$(NoLogo)</LibNoLogo>
+    <LibBindFiles Condition=" '$(LibBindFiles)' == '' ">$(BindFiles)</LibBindFiles>
+    <LibPedantic Condition=" '$(LibPedantic)' == '' ">$(Pedantic)</LibPedantic>
+    <LibSuppressAllWarnings Condition=" '$(LibSuppressAllWarnings)' == '' ">$(SuppressAllWarnings)</LibSuppressAllWarnings>
+    <LibSuppressSpecificWarnings Condition=" '$(LibSuppressSpecificWarnings)' == '' ">$(SuppressSpecificWarnings)</LibSuppressSpecificWarnings>
+    <LibSuppressSchemaValidation Condition=" '$(LibSuppressSchemaValidation)' == '' ">$(SuppressSchemaValidation)</LibSuppressSchemaValidation>
+    <LibSuppressIntermediateFileVersionMatching Condition=" '$(LibSuppressIntermediateFileVersionMatching)' == '' ">$(SuppressIntermediateFileVersionMatching)</LibSuppressIntermediateFileVersionMatching>
+    <LibTreatWarningsAsErrors Condition=" '$(LibTreatWarningsAsErrors)' == '' ">$(TreatWarningsAsErrors)</LibTreatWarningsAsErrors>
+    <LibTreatSpecificWarningsAsErrors Condition=" '$(LibTreatSpecificWarningsAsErrors)' == '' ">$(TreatSpecificWarningsAsErrors)</LibTreatSpecificWarningsAsErrors>
+    <LibVerboseOutput Condition=" '$(LibVerboseOutput)' == '' ">$(VerboseOutput)</LibVerboseOutput>
+  </PropertyGroup>
+
+  <!-- Default Linker properties. -->
+  <PropertyGroup>
+    <LinkerNoLogo Condition=" '$(LinkerNoLogo)' == '' ">$(NoLogo)</LinkerNoLogo>
+    <LinkerBindFiles Condition=" '$(LinkerBindFiles)' == '' ">$(BindFiles)</LinkerBindFiles>
+    <LinkerPedantic Condition=" '$(LinkerPedantic)' == '' ">$(Pedantic)</LinkerPedantic>
+    <LinkerSuppressAllWarnings Condition=" '$(LinkerSuppressAllWarnings)' == '' ">$(SuppressAllWarnings)</LinkerSuppressAllWarnings>
+    <LinkerSuppressSpecificWarnings Condition=" '$(LinkerSuppressSpecificWarnings)' == '' ">$(SuppressSpecificWarnings)</LinkerSuppressSpecificWarnings>
+    <LinkerSuppressSchemaValidation Condition=" '$(LinkerSuppressSchemaValidation)' == '' ">$(SuppressSchemaValidation)</LinkerSuppressSchemaValidation>
+    <LinkerSuppressIntermediateFileVersionMatching Condition=" '$(LinkerSuppressIntermediateFileVersionMatching)' == '' ">$(SuppressIntermediateFileVersionMatching)</LinkerSuppressIntermediateFileVersionMatching>
+    <LinkerTreatWarningsAsErrors Condition=" '$(LinkerTreatWarningsAsErrors)' == '' ">$(TreatWarningsAsErrors)</LinkerTreatWarningsAsErrors>
+    <LinkerTreatSpecificWarningsAsErrors Condition=" '$(LinkerTreatSpecificWarningsAsErrors)' == '' ">$(TreatSpecificWarningsAsErrors)</LinkerTreatSpecificWarningsAsErrors>
+    <LinkerVerboseOutput Condition=" '$(LinkerVerboseOutput)' == '' ">$(VerboseOutput)</LinkerVerboseOutput>
+  </PropertyGroup>
+
+  <!-- If BindInputPaths (or LinkerBindInputPaths) was passed in via the command line, then convert it to an ItemGroup -->
+  <ItemGroup>
+    <BindInputPaths Include="$(BindInputPaths)"  Condition=" '$(BindInputPaths)' != '' " />
+    <LinkerBindInputPaths Include="$(LinkerBindInputPaths)"  Condition=" '$(LinkerBindInputPaths)' != '' " />
+  </ItemGroup>
+
+  <!-- Default Lit and Light "properties" -->
+  <ItemGroup>
+    <LinkerBindInputPaths Condition=" '@(LinkerBindInputPaths)' == '' " Include="@(BindInputPaths)" />
+  </ItemGroup>
+
+  <!--
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  Initial Targets
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  -->
+
+  <!--
+  ==================================================================================================
+  _CheckRequiredProperties
+
+    Checks properties that must be set in the main project file or on the command line before
+    using this .TARGETS file.
+
+    [IN]
+    $(OutputName) - The name of the MSI/MSM/wixlib to build (without the extension)
+    $(OutputType) - Possible values are 'package', 'PatchCreation', 'module', 'library', 'bundle'
+  ==================================================================================================
+  -->
+  <PropertyGroup>
+    <_PleaseSetThisInProjectFile>Please set this in the project file before the &lt;Import&gt; of the wix.targets file.</_PleaseSetThisInProjectFile>
+    <_OutputTypeDescription>The OutputType defines whether a Windows Installer package (.msi), PatchCreation (.pcp), merge module (.msm), wix library (.wixlib), or self-extracting executable (.exe) is being built. $(_PleaseSetThisInProjectFile) Possible values are 'Package', 'Module', 'Library', and 'Bundle'.</_OutputTypeDescription>
+  </PropertyGroup>
+  <Target Name="_CheckRequiredProperties">
+
+    <Error
+      Code="WIXTARGETS100"
+      Condition=" '$(OutputName)' == '' "
+      Text="The OutputName property is not set in project &quot;$(MSBuildProjectFile)&quot;. The OutputName defines the name of the output without a file extension. $(_PleaseSetThisInProjectFile)" />
+
+    <Warning
+      Code="WIXTARGETS101"
+      Condition=" '$(_OriginalOutputType)' == '' "
+      Text="The OutputType property is not set in project &quot;$(MSBuildProjectFile)&quot;. Defaulting to '$(OutputType)'. $(_OutputTypeDescription)" />
+
+    <Error
+      Code="WIXTARGETS102"
+      Condition=" '$(OutputType)' != 'Package' and '$(OutputType)' != 'PatchCreation' and '$(OutputType)' != 'Module' and '$(OutputType)' != 'Library' and '$(OutputType)' != 'Bundle' "
+      Text="The OutputType property '$(OutputType)' is not valid in project &quot;$(MSBuildProjectFile)&quot;. $(_OutputTypeDescription)" />
+
+    <Error
+      Code="WIXTARGETS103"
+      Condition=" '$(MSBuildToolsVersion)' == '' OR '$(MSBuildToolsVersion)' &lt; '4.0' "
+      Text="MSBuild v$(MSBuildToolsVersion) is not supported by the project &quot;$(MSBuildProjectFile)&quot;. You must use MSBuild v4.0 or later." />
+
+  </Target>
+
+  <!--
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  Build Targets
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  -->
+
+  <!--
+  ==================================================================================================
+  CoreBuild - OVERRIDE DependsOn
+
+    The core build step calls each of the build targets.
+
+    This is where we insert our targets into the build process.
+  ==================================================================================================
+  -->
+  <PropertyGroup>
+    <CoreBuildDependsOn>
+      BuildOnlySettings;
+      PrepareForBuild;
+      PreBuildEvent;
+      ResolveReferences;
+
+      <!--CompileAndLink;-->
+      DoIt;
+      Signing;
+
+      GetTargetPath;
+      PrepareForRun;
+      IncrementalClean;
+      PostBuildEvent
+    </CoreBuildDependsOn>
+  </PropertyGroup>
+
+
+  <!--
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  Resolve References Targets
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  -->
+
+  <!--
+  ==================================================================================================
+  ResolveReferences - OVERRIDE DependsOn
+
+  ==================================================================================================
+  -->
+  <PropertyGroup>
+    <ResolveReferencesDependsOn>
+      BeforeResolveReferences;
+      AssignProjectConfiguration;
+      ResolveProjectReferences;
+      ResolveWixLibraryReferences;
+      ResolveWixExtensionReferences;
+      AfterResolveReferences
+    </ResolveReferencesDependsOn>
+  </PropertyGroup>
+
+  <!--
+  ================================================================================================
+  ResolveProjectReferences
+
+    Builds all of the referenced projects to get their outputs.
+
+    [IN]
+    @(NonVCProjectReference) - The list of non-VC project references.
+
+    [OUT]
+    @(ProjectReferenceWithConfiguration) - The list of non-VC project references.
+    @(WixLibProjects) - Paths to any .wixlibs that were built by referenced projects.
+  ================================================================================================
+  -->
+  <Target
+    Name="ResolveProjectReferences"
+    DependsOnTargets="AssignProjectConfiguration;_SplitProjectReferencesByFileExistence"
+    Condition=" '@(ProjectReferenceWithConfiguration)' != '' ">
+
+    <!-- Issue a warning for each non-existent project. -->
+    <Warning
+      Text="The referenced project '%(_MSBuildProjectReferenceNonexistent.Identity)' does not exist."
+      Condition=" '@(_MSBuildProjectReferenceNonexistent)' != '' " />
+
+    <!--
+    When building this project from the IDE or when building a .sln from the command line or
+    when only building .wixlib project references, gather the referenced build outputs. The
+    code that builds the .sln will already have built the project, so there's no need to do
+    it again here and when building only .wixlib project references we'll use the results to
+    determine which projects to build.
+
+    The ContinueOnError setting is here so that, during project load, as much information as
+    possible will be passed to the compilers.
+    -->
+    <MSBuild
+      Projects="@(_MSBuildProjectReferenceExistent)"
+      Targets="%(_MSBuildProjectReferenceExistent.Targets);GetTargetPath"
+      Properties="%(_MSBuildProjectReferenceExistent.SetConfiguration);%(_MSBuildProjectReferenceExistent.SetPlatform)"
+      Condition="('$(BuildingSolutionFile)' == 'true' or '$(BuildingInsideVisualStudio)' == 'true' or '$(BuildProjectReferences)' != 'true') and '@(_MSBuildProjectReferenceExistent)' != '' "
+      ContinueOnError="!$(BuildingProject)">
+
+      <Output TaskParameter="TargetOutputs" ItemName="_GatheredProjectReferencePaths" />
+    </MSBuild>
+
+    <!--
+    Determine which project references should be built. Note: we will not build any project references
+    if building in the IDE because it builds project references directly.
+
+    If BuildProjectReferences is 'true' (the default) then take all MSBuild project references that exist
+    on disk and add them to the list of things to build. This is the easy case.
+    -->
+    <CreateItem
+      Include="@(_MSBuildProjectReferenceExistent)"
+      Condition=" '$(BuildProjectReferences)' == 'true' and '$(BuildingInsideVisualStudio)' != 'true' ">
+
+      <Output TaskParameter="Include" ItemName="_ProjectReferencesToBuild" />
+    </CreateItem>
+
+    <!--
+    If BuildProjectReferences is 'wixlib' then build only the MSBuild project references that exist and
+    create a .wixlib file. That requires us to first filter the gathered project references down to only
+    those that build .wixlibs.
+    -->
+    <CreateItem
+      Include="@(_GatheredProjectReferencePaths)"
+      Condition=" '$(BuildProjectReferences)' == 'wixlib' and '%(Extension)' == '.wixlib' and '$(BuildingInsideVisualStudio)' != 'true' ">
+
+      <Output TaskParameter="Include" ItemName="_ReferencedWixLibPaths" />
+    </CreateItem>
+
+    <!--
+    The second step when building only 'wixlib' project references is to create the list of existing MSBuild
+    project references that do *not* build a .wixlib. These are the projects that will be skipped.
+     -->
+    <CreateItem
+      Include="@(_MSBuildProjectReferenceExistent->'%(FullPath)')"
+      Exclude="@(_ReferencedWixLibPaths->'%(MSBuildSourceProjectFile)')"
+      Condition=" '$(BuildProjectReferences)' == 'wixlib' and '$(BuildingInsideVisualStudio)' != 'true' ">
+
+      <Output TaskParameter="Include" ItemName="_ProjectReferencesToSkip" />
+    </CreateItem>
+
+    <!--
+    Finally, when building only 'wixlib' project references, the list of projects to build are naturally the
+    list of projects *not* being skipped.
+    -->
+    <CreateItem
+      Include="@(_MSBuildProjectReferenceExistent->'%(FullPath)')"
+      Exclude="@(_ProjectReferencesToSkip)"
+      Condition=" '$(BuildProjectReferences)' == 'wixlib' and '$(BuildingInsideVisualStudio)' != 'true' ">
+
+      <Output TaskParameter="Include" ItemName="_ProjectReferencesToBuild" />
+    </CreateItem>
+
+    <!-- Display a warning for all projects being skipped. -->
+    <Warning
+      Text="BuildProjectReferences set to '$(BuildProjectReferences)'. Skipping the non-Library project: %(_ProjectReferencesToSkip.Identity)"
+      Condition=" '@(_ProjectReferencesToSkip)' != '' " />
+
+    <Message
+      Importance="low"
+      Text="Project reference to build: %(_ProjectReferencesToBuild.Identity), properties: %(_ProjectReferencesToBuild.Properties)"
+      Condition=" '@(_ProjectReferencesToBuild)' != '' " />
+
+    <!--
+    Build referenced projects when building from the command line.
+
+    The $(ProjectReferenceBuildTargets) will normally be blank so that the project's default target
+    is used during a P2P reference. However if a custom build process requires that the referenced
+    project has a different target to build it can be specified.
+    -->
+    <MSBuild
+      Projects="@(_ProjectReferencesToBuild)"
+      Targets="$(ProjectReferenceBuildTargets)"
+      Properties="%(_ProjectReferencesToBuild.SetConfiguration);%(_ProjectReferencesToBuild.SetPlatform)"
+      Condition=" '@(_ProjectReferencesToBuild)' != '' ">
+
+      <Output TaskParameter="TargetOutputs" ItemName="_BuiltProjectReferencePaths" />
+    </MSBuild>
+
+    <!-- 
+    VC project references must build GetNativeTargetPath because neither GetTargetPath nor the return of the default build
+    target return the output for a native .vcxproj. 
+    -->
+    <MSBuild
+      Projects="@(_MSBuildProjectReferenceExistent)"
+      Targets="GetNativeTargetPath"
+      Properties="%(_MSBuildProjectReferenceExistent.SetConfiguration);%(_MSBuildProjectReferenceExistent.SetPlatform)"
+      Condition=" '@(ProjectReferenceWithConfiguration)' != '' and '%(_MSBuildProjectReferenceExistent.Extension)' == '.vcxproj' ">
+
+      <Output TaskParameter="TargetOutputs" ItemName="_ResolvedProjectReferencePaths" />
+      <Output TaskParameter="TargetOutputs" ItemName="_MSBuildResolvedProjectReferencePaths" />
+    </MSBuild>
+
+    <!-- Assign the unique gathered and built project references to the resolved project
+         reference paths. -->
+    <RemoveDuplicates Inputs="@(_GatheredProjectReferencePaths);@(_BuiltProjectReferencePaths)">
+      <Output TaskParameter="Filtered" ItemName="_ResolvedProjectReferencePaths" />
+      <Output TaskParameter="Filtered" ItemName="_MSBuildResolvedProjectReferencePaths" />
+    </RemoveDuplicates>
+
+    <!-- Create list of all .wixlib project references. -->
+    <CreateItem
+      Include="@(_ResolvedProjectReferencePaths)"
+      Condition=" '%(Extension)' == '.wixlib' ">
+
+      <Output TaskParameter="Include" ItemName="WixLibProjects" />
+    </CreateItem>
+
+    <Message
+      Importance="low"
+      Text="Library from referenced projects: %(WixLibProjects.Identity)"
+      Condition=" '@(WixLibProjects)' != '' " />
+
+  </Target>
+
+  <!--
+  ================================================================================================
+  ResolveWixLibraryReferences
+
+    Resolve the library references to full paths.
+
+    [IN]
+    @(WixLibrary) - The list of .wixlib files.
+    
+    [OUT]
+    @(_ResolvedWixLibraryPaths) - Item group with full paths to libraries
+  ================================================================================================
+  -->
+  <PropertyGroup>
+    <ResolveWixLibraryReferencesDependsOn></ResolveWixLibraryReferencesDependsOn>
+  </PropertyGroup>
+  <Target
+    Name="ResolveWixLibraryReferences"
+    DependsOnTargets="$(ResolveWixLibraryReferencesDependsOn)"
+    Condition=" '@(WixLibrary)' != ''">
+
+    <!--
+    The WixLibrarySearchPaths property is set to find assemblies in the following order:
+
+        (1) $(ReferencePaths) - the reference paths property, which comes from the .USER file.
+        (2) The hintpath from the referenced item itself, indicated by {HintPathFromItem}.
+        (3) Treat the reference's Include as if it were a real file name.
+        (4) Path specified by the WixExtDir property.
+    -->
+    <CreateProperty Condition=" '$(WixLibrarySearchPaths)' == '' " Value="
+      $(ReferencePaths);
+      {HintPathFromItem};
+      {RawFileName};
+      $(WixExtDir)
+      ">
+      <Output TaskParameter="Value" PropertyName="WixLibrarySearchPaths" />
+    </CreateProperty>
+
+    <ResolveWixReferences
+      WixReferences="@(WixLibrary)"
+      SearchPaths="$(WixLibrarySearchPaths)"
+      SearchFilenameExtensions=".wixlib">
+      <Output TaskParameter="ResolvedWixReferences" ItemName="_AllResolvedWixLibraryPaths" />
+    </ResolveWixReferences>
+
+    <!-- Remove duplicate library items that would cause build errors -->
+    <RemoveDuplicates Inputs="@(_AllResolvedWixLibraryPaths)">
+      <Output TaskParameter="Filtered" ItemName="_ResolvedWixLibraryPaths" />
+    </RemoveDuplicates>
+
+  </Target>
+
+  <!--
+  ==================================================================================================
+  ResolveWixExtensionReferences
+
+    Resolves WiX extension references to full paths. Any properties you use
+    to resolve paths to extensions must be defined before importing this
+    file or the extensions will be automatically resolved to $(WixExtDir).
+
+    [IN]
+    @(WixExtension) - WixExtension item group
+
+    [OUT]
+    @(_ResolvedWixExtensionPaths) - Item group with full paths to extensions
+  ==================================================================================================
+  -->
+  <PropertyGroup>
+    <ResolveWixExtensionReferencesDependsOn></ResolveWixExtensionReferencesDependsOn>
+  </PropertyGroup>
+  <Target
+    Name="ResolveWixExtensionReferences"
+    DependsOnTargets="$(ResolveWixExtensionReferencesDependsOn)"
+    Condition=" '@(WixExtension)' != ''">
+
+    <!--
+    The WixExtensionSearchPaths property is set to find assemblies in the following order:
+
+        (1) $(ReferencePaths) - the reference paths property, which comes from the .USER file.
+        (2) The hintpath from the referenced item itself, indicated by {HintPathFromItem}.
+        (3) Treat the reference's Include as if it were a real file name.
+        (4) Path specified by the WixExtDir property.
+    -->
+    <CreateProperty Condition=" '$(WixExtensionSearchPaths)' == '' " Value="
+      $(ReferencePaths);
+      {HintPathFromItem};
+      {RawFileName};
+      $(WixExtDir)
+      ">
+      <Output TaskParameter="Value" PropertyName="WixExtensionSearchPaths" />
+    </CreateProperty>
+
+    <ResolveWixReferences
+      WixReferences="@(WixExtension)"
+      SearchPaths="$(WixExtensionSearchPaths)"
+      SearchFilenameExtensions=".dll">
+      <Output TaskParameter="ResolvedWixReferences" ItemName="_AllResolvedWixExtensionPaths" />
+    </ResolveWixReferences>
+
+    <!-- Remove duplicate extension items that would cause build errors -->
+    <RemoveDuplicates Inputs="@(_AllResolvedWixExtensionPaths)">
+      <Output TaskParameter="Filtered" ItemName="_ResolvedWixExtensionPaths" />
+    </RemoveDuplicates>
+  </Target>
+
+  <!--
+  ================================================================================================
+  GetTargetPath - OVERRIDE DependsOn
+
+    This stand-alone target returns the name of the build product (i.e. MSI, MSM) that would be
+    produced if we built this project.
+  ================================================================================================
+  -->
+  <PropertyGroup>
+    <GetTargetPathDependsOn>AssignCultures</GetTargetPathDependsOn>
+  </PropertyGroup>
+
+
+  <!--
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  DoIt Targets
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  -->
+
+  <!--
+  ==================================================================================================
+  DoIt
+  ==================================================================================================
+  -->
+  <PropertyGroup>
+    <DoItDependsOn>
+      PrepareForBuild;
+      ResolveReferences;
+      BeforeCompile;
+      _TimeStampBeforeCompile;
+      Harvest;
+
+      CalculateDefineConstants;
+      GenerateCompileWithObjectPath;
+
+      AssignCultures;
+      ReadPreviousBindInputsAndBuiltOutputs;
+
+      ActuallyDoIt;
+
+      UpdateLinkFileWrites;
+      _TimeStampAfterCompile;
+      AfterCompile
+    </DoItDependsOn>
+  </PropertyGroup>
+  <Target 
+    Name="DoIt"
+    DependsOnTargets="$(DoItDependsOn)" />
+    
+  <Target
+    Name="ActuallyDoIt"
+
+    Inputs="@(Compile);
+    @(Content);
+    @(EmbeddedResource);
+    @(WixObject);
+    @(_ResolvedProjectReferencePaths);
+    @(_ResolvedWixLibraryPaths);
+    @(_ResolvedWixExtensionPaths);
+    @(_BindInputs);
+    $(MSBuildAllProjects)"
+    Outputs="$(IntermediateOutputPath)%(CultureGroup.OutputFolder)$(BindBuiltOutputsFile);@(_BindBuiltOutputs)"
+    Condition=" '@(Compile)' != '' and ('$(OutputType)' == 'Bundle' or '$(OutputType)' == 'Package' or '$(OutputType)' == 'PatchCreation' or '$(OutputType)' == 'Module')">
+
+
+    <PropertyGroup>
+      <PdbOutputFile>$(TargetPdbDir)%(CultureGroup.OutputFolder)$(TargetPdbName)</PdbOutputFile>
+    </PropertyGroup>
+
+    <DoIt
+        SourceFiles="@(_CompileWithObjectPath)"
+        LocalizationFiles="@(EmbeddedResource)"
+        ObjectFiles="@(CompileObjOutput);@(WixObject);@(WixLibProjects);@(_ResolvedWixLibraryPaths)"
+
+        Cultures="%(CultureGroup.Identity)"
+
+        ExtensionDirectory="$(WixExtDir)"
+        Extensions="@(_ResolvedWixExtensionPaths)"
+
+        IntermediateDirectory="$(IntermediateOutputPath)"
+
+        OutputFile="$(IntermediateOutputPath)%(CultureGroup.OutputFolder)$(TargetName)$(TargetExt)"
+        PdbOutputFile="$(PdbOutputFile)"
+
+        AdditionalOptions="$(CompilerAdditionalOptions) $(LinkerAdditionalOptions)"
+        DefineConstants="$(DefineConstants);$(SolutionDefineConstants);$(ProjectDefineConstants);$(ProjectReferenceDefineConstants)"
+        IncludeSearchPaths="$(IncludeSearchPaths)"
+        InstallerPlatform="$(InstallerPlatform)"
+        NoLogo="true"
+        Pedantic="$(Pedantic)"
+        ReferencePaths="$(ReferencePaths)"
+
+        SuppressSpecificWarnings="$(CompilerSuppressSpecificWarnings);$(LinkerSuppressSpecificWarnings)"
+        TreatSpecificWarningsAsErrors="$(CompilerTreatSpecificWarningsAsErrors)"
+
+        BindInputPaths="@(LinkerBindInputPaths)"
+        BindFiles="$(LinkerBindFiles)"
+        BindContentsFile="$(IntermediateOutputPath)%(CultureGroup.OutputFolder)$(BindContentsFile)"
+        BindOutputsFile="$(IntermediateOutputPath)%(CultureGroup.OutputFolder)$(BindOutputsFile)"
+        BindBuiltOutputsFile="$(IntermediateOutputPath)%(CultureGroup.OutputFolder)$(BindBuiltOutputsFile)"
+
+        CabinetCachePath="$(CabinetCachePath)"
+        CabinetCreationThreadCount="$(CabinetCreationThreadCount)"
+        DefaultCompressionLevel="$(DefaultCompressionLevel)"
+
+        UnreferencedSymbolsFile="$(UnreferencedSymbolsFile)"
+        WixProjectFile="$(ProjectPath)"
+        WixVariables="$(WixVariables)" 
+
+        SuppressValidation="$(SuppressValidation)"
+        SuppressIces="$(SuppressIces)"
+        AdditionalCub="$(AdditionalCub)" />
+
+    <!--
+    SuppressAllWarnings="$(CompilerSuppressAllWarnings);$(LinkerSuppressAllWarnings)"
+    TreatWarningsAsErrors="$(CompilerTreatWarningsAsErrors);$(LinkerTreatWarningsAsErrors)"
+    VerboseOutput="$(CompilerVerboseOutput);$(LinkerVerboseOutput)"
+    -->
+
+</Target>
+
+
+  <!--
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  CompileAndLink Targets
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  -->
+
+  <!--
+  ==================================================================================================
+  CompileAndLink
+  ==================================================================================================
+  -->
+  <PropertyGroup>
+    <CompileAndLinkDependsOn>
+      ResolveReferences;
+      BeforeCompile;
+      _TimeStampBeforeCompile;
+      Harvest;
+      Compile;
+      Lib;
+      Link;
+      UpdateLinkFileWrites;
+      _TimeStampAfterCompile;
+      AfterCompile
+    </CompileAndLinkDependsOn>
+  </PropertyGroup>
+  <Target
+    Name="CompileAndLink"
+    DependsOnTargets="$(CompileAndLinkDependsOn)" />
+
+  <!--
+  ==================================================================================================
+  CalculateDefineConstants
+
+    Adds project references to the constants passed into the compiler.
+
+    [IN]
+    @(_ResolvedProjectReferencePaths) - paths to projects' outputs
+    $(VSProjectConfigurations) - map of project names to configurations, provided by VS when building in the IDE
+
+    [OUT]
+    $(ProjectReferenceDefineConstants) - the list of referenced project variables to be passed into the compiler
+  ==================================================================================================
+  -->
+  <PropertyGroup>
+    <CalculateDefineConstantsDependsOn>ResolveReferences</CalculateDefineConstantsDependsOn>
+  </PropertyGroup>
+  <Target
+      Name="CalculateDefineConstants"
+      DependsOnTargets="$(CalculateDefineConstantsDependsOn)"
+      Condition=" '@(_ResolvedProjectReferencePaths)' != '' ">
+
+    <PropertyGroup>
+      <ProjectDefineConstants>
+        Configuration=$(ConfigurationName);
+        OutDir=$(OutDir);
+        Platform=$(PlatformName);
+        ProjectDir=$(ProjectDir);
+        ProjectExt=$(ProjectExt);
+        ProjectFileName=$(ProjectFileName);
+        ProjectName=$(ProjectName);
+        ProjectPath=$(ProjectPath);
+        TargetDir=$(TargetDir);
+        TargetExt=$(TargetExt);
+        TargetFileName=$(TargetFileName);
+        TargetName=$(TargetName);
+        TargetPath=$(TargetPath);
+      </ProjectDefineConstants>
+    </PropertyGroup>
+
+    <PropertyGroup>
+      <SolutionDefineConstants Condition=" '$(DevEnvDir)'!='*Undefined*' ">$(SolutionDefineConstants);DevEnvDir=$(DevEnvDir)</SolutionDefineConstants>
+      <SolutionDefineConstants Condition=" '$(SolutionDir)'!='*Undefined*' ">$(SolutionDefineConstants);SolutionDir=$(SolutionDir)</SolutionDefineConstants>
+      <SolutionDefineConstants Condition=" '$(SolutionExt)'!='*Undefined*' ">$(SolutionDefineConstants);SolutionExt=$(SolutionExt)</SolutionDefineConstants>
+      <SolutionDefineConstants Condition=" '$(SolutionFileName)'!='*Undefined*' ">$(SolutionDefineConstants);SolutionFileName=$(SolutionFileName)</SolutionDefineConstants>
+      <SolutionDefineConstants Condition=" '$(SolutionName)'!='*Undefined*' ">$(SolutionDefineConstants);SolutionName=$(SolutionName)</SolutionDefineConstants>
+      <SolutionDefineConstants Condition=" '$(SolutionPath)'!='*Undefined*' ">$(SolutionDefineConstants);SolutionPath=$(SolutionPath)</SolutionDefineConstants>
+    </PropertyGroup>
+
+    <CreateProjectReferenceDefineConstants
+        ProjectReferencePaths="@(_ResolvedProjectReferencePaths)"
+        ProjectConfigurations="$(VSProjectConfigurations)">
+
+      <Output TaskParameter="DefineConstants" PropertyName="ProjectReferenceDefineConstants" />
+    </CreateProjectReferenceDefineConstants>
+  </Target>
+
+  <!--
+  ================================================================================================
+  GenerateCompileWithObjectPath
+
+    Generates metadata on the for compile output objects.
+
+  ================================================================================================
+  -->
+  <PropertyGroup>
+    <GenerateCompileWithObjectPathDependsOn></GenerateCompileWithObjectPathDependsOn>
+  </PropertyGroup>
+  <Target
+      Name="GenerateCompileWithObjectPath"
+      Condition=" '@(Compile)' != '' ">
+
+    <GenerateCompileWithObjectPath
+        Compile="@(Compile)"
+        IntermediateOutputPath="$(IntermediateOutputPath)">
+      <Output TaskParameter="CompileWithObjectPath" ItemName="_CompileWithObjectPath" />
+    </GenerateCompileWithObjectPath>
+
+  </Target>
+
+  <!--
+  ================================================================================================
+  Compile
+
+    Compiles the wxs files into wixobj files using candle.exe.
+
+    [IN]
+    @(Compile) - The list of wxs files to compile.
+    @(Content) - Files that the project uses in the installer.
+    @(WixExtension) - The list of wixlib or wix dll extensions.
+
+    [OUT]
+    @(CompileObjOutput) - The compiled .wixobj files.
+  ================================================================================================
+  -->
+  <PropertyGroup>
+    <CompileDependsOn>
+      PrepareForBuild;
+      ResolveReferences;
+      CalculateDefineConstants;
+      GenerateCompileWithObjectPath
+    </CompileDependsOn>
+  </PropertyGroup>
+  <Target
+      Name="Compile"
+      Inputs="@(Compile);
+              @(Content);
+              @(_ResolvedWixExtensionPaths);
+              @(_ResolvedProjectReferencePaths);
+              $(MSBuildAllProjects)"
+      Outputs="@(_CompileWithObjectPath -> '%(ObjectPath)%(Filename).wixobj')"
+      DependsOnTargets="$(CompileDependsOn)"
+      Condition=" '@(Compile)' != '' ">
+
+    <Candle
+        SourceFiles="@(_CompileWithObjectPath)"
+        AdditionalOptions="$(CompilerAdditionalOptions)"
+        DefineConstants="$(DefineConstants);$(SolutionDefineConstants);$(ProjectDefineConstants);$(ProjectReferenceDefineConstants)"
+        ExtensionDirectory="$(WixExtDir)"
+        Extensions="@(_ResolvedWixExtensionPaths)"
+        PreprocessToStdOut="$(PreprocessToStdOut)"
+        PreprocessToFile="$(PreprocessToFile)"
+        IncludeSearchPaths="$(IncludeSearchPaths)"
+        InstallerPlatform="$(InstallerPlatform)"
+        IntermediateDirectory="$(IntermediateOutputPath)"
+        NoLogo="$(CompilerNoLogo)"
+        OutputFile="%(_CompileWithObjectPath.ObjectPath)"
+        Pedantic="$(Pedantic)"
+        ReferencePaths="$(ReferencePaths)"
+        RunAsSeparateProcess="$(RunWixToolsOutOfProc)"
+        SuppressAllWarnings="$(CompilerSuppressAllWarnings)"
+        SuppressSpecificWarnings="$(CompilerSuppressSpecificWarnings)"
+        ToolPath="$(WixToolDir)"
+        TreatWarningsAsErrors="$(CompilerTreatWarningsAsErrors)"
+        TreatSpecificWarningsAsErrors="$(CompilerTreatSpecificWarningsAsErrors)"
+        VerboseOutput="$(CompilerVerboseOutput)">
+    </Candle>
+
+    <!-- These will be still be set even if the Compile target is up to date. -->
+    <ItemGroup>
+      <CompileObjOutput Include="@(_CompileWithObjectPath -> '%(ObjectPath)%(Filename).wixobj')" />
+      <FileWrites Include="@(CompileObjOutput)" />
+    </ItemGroup>
+  </Target>
+
+  <!--
+  ================================================================================================
+  Lib
+
+    Links the .wixobj, .wxl, .wixlib, wix extensions into a .wixlib file using lit.exe.
+
+    [IN]
+    @(CompileObjOutput) - The compiled .wixobj file.
+    @(EmbeddedResource) - The list of wxl files to use for localization.
+    @(WixObject) - The list of .wixobj files.
+    @(WixLibrary) - The list of .wixlib files.
+    @(WixExtension) - The list of wix dll extension files.
+
+    [OUT]
+    $(TargetPath) - The compiled .wixlib file.
+  ================================================================================================
+  -->
+  <PropertyGroup>
+    <LibDependsOn>
+      PrepareForBuild;
+      ResolveReferences
+    </LibDependsOn>
+  </PropertyGroup>
+  <Target
+      Name="Lib"
+      Inputs="@(CompileObjOutput);
+              @(EmbeddedResource);
+              @(WixObject);
+              @(WixLibrary);
+              @(_ResolvedWixExtensionPaths);
+              $(MSBuildAllProjects)"
+      Outputs="$(TargetPath)"
+      DependsOnTargets="$(LibDependsOn)"
+      Condition=" '$(OutputType)' == 'Library' ">
+
+    <Lit
+      ObjectFiles="@(CompileObjOutput);@(WixObject);@(WixLibProjects);@(WixLibrary)"
+      AdditionalOptions="$(LibAdditionalOptions)"
+      BindInputPaths="@(LinkerBindInputPaths)"
+      BindFiles="$(LibBindFiles)"
+      ExtensionDirectory="$(WixExtDir)"
+      Extensions="@(_ResolvedWixExtensionPaths)"
+      LocalizationFiles="@(EmbeddedResource)"
+      NoLogo="$(LibNoLogo)"
+      OutputFile="$(TargetPath)"
+      Pedantic="$(LibPedantic)"
+      ReferencePaths="$(ReferencePaths)"
+      RunAsSeparateProcess="$(RunWixToolsOutOfProc)"
+      SuppressAllWarnings="$(LibSuppressAllWarnings)"
+      SuppressIntermediateFileVersionMatching="$(LibSuppressIntermediateFileVersionMatching)"
+      SuppressSchemaValidation="$(LibSuppressSchemaValidation)"
+      SuppressSpecificWarnings="$(LibSuppressSpecificWarnings)"
+      ToolPath="$(WixToolDir)"
+      TreatWarningsAsErrors="$(LibTreatWarningsAsErrors)"
+      VerboseOutput="$(LibVerboseOutput)" />
+  </Target>
+
+  <!--
+  ================================================================================================
+  AssignCultures
+
+    Determines the final list of culture groups to build based on either the Cultures property or
+    those specified in .wxl files. 
+
+      Culture groups specified in the Cultures property must be specified as a semi-colon 
+      delimited  list of groups, with comma-delimited cultures within a group.  
+      For example:
+        <Cultures>en-US,en;en-GB,en</Cultures>
+      This will build 2 targets, outputing to en-US and en-GB sub-folders.  Light will first look
+      for strings in the first culture (en-US or en-GB) then the second (en).
+
+      Cultures of .wxl files will be used when the Culture property is not set.  The culture of a 
+      .wxl file is determined by the Culture attribute in the WixLocalization element in the file
+
+    Sets the OutputFolder metadata on each culture group.  In most cases this is the same as the 
+    first culture in the culture group.  When the Culture's property is unspecified and no .wxl 
+    files are provided this is the same as the output directory.  When the Culture's property 
+    specifies a single culture group and no .wxl files are provided this is the same as the output
+    directory.
+
+    Updates the TargetPath and TargetPdbPath properties to be used in subsequent targets.
+
+    [IN]
+    @(EmbeddedResource) - The list of wxl files to use for localization.
+    $(Cultures) - The list of culture groups to build.
+
+    [OUT]
+    @(CultureGroup) - The list of culture group strings with OutputFolder metadata
+    $(TargetPath) - Property list of target link output MSIs/MSMs
+    $(TargetPdbPath) - Property list of target output pdbs
+    @(SignTargetPath) - The list of target to be signed
+
+  ================================================================================================
+  -->
+  <Target
+      Name="AssignCultures"
+      Condition=" '$(OutputType)' == 'Package' or '$(OutputType)' == 'PatchCreation' or '$(OutputType)' == 'Module' ">
+
+    <WixAssignCulture
+        Cultures="$(Cultures)"
+        Files="@(EmbeddedResource)">
+
+      <Output TaskParameter="CultureGroups" ItemName="CultureGroup" />
+    </WixAssignCulture>
+
+    <!-- Build an itemgroup of outputs -->
+    <ItemGroup>
+      <_TargetPathItems Include="$(TargetDir)%(CultureGroup.OutputFolder)$(TargetName)$(TargetExt)" />
+      <_TargetPdbPathItems Include="$(TargetPdbDir)%(CultureGroup.OutputFolder)$(TargetPdbName)" />
+    </ItemGroup>
+
+    <!-- Convert the itemgroup to a semicolon-delimited property -->
+    <PropertyGroup>
+      <TargetPath>@(_TargetPathItems)</TargetPath>
+      <TargetPdbPath>@(_TargetPdbPathItems)</TargetPdbPath>
+    </PropertyGroup>
+
+    <!-- Set the sign target items, if we're signing output. -->
+    <ItemGroup Condition=" '$(SignOutput)' == 'true' AND '$(SuppressLayout)' != 'true' ">
+      <SignTargetPath Include="@(_TargetPathItems)" />
+    </ItemGroup>
+  </Target>
+
+  <!--
+  ================================================================================================
+  ReadPreviousBindInputsAndBuiltOutputs
+
+    Reads a previous build's Bind contents and built outputs file into @(_BindInputs) and
+    @(_BindBuiltOutputs) respectively.
+
+    Note: Only the *built* outputs are used because using files copied to output folder
+          can cause perpetual incremental build.
+
+          Imagine the case where you have: Msi.wixproj -> Lib.wixproj -> Exe.csproj. The
+          Exe.csproj cannot be both an input to Lib.wixproj and an output of Msi.wixproj
+          (as an uncompressed file) because the Lib.wixproj will always newer than the
+          Exe.csproj.
+
+    [IN]
+
+    [OUT]
+    @(_BindInputs) - the content files required to bind (i.e. the Binary/@SourceFile and File/@Source files).
+    @(_BindBuiltOutputs) - the previously built .msi, .msm, .pcp, .exe .wixpdb, .cabs, etc.
+                           Does not include content copied to output folder.
+  ================================================================================================
+  -->
+  <Target
+    Name="ReadPreviousBindInputsAndBuiltOutputs"
+    Condition=" '$(OutputType)' == 'Bundle' or '$(OutputType)' == 'Package' or '$(OutputType)' == 'PatchCreation' or '$(OutputType)' == 'Module' ">
+
+    <ReadLinesFromFile File="$(IntermediateOutputPath)%(CultureGroup.OutputFolder)$(BindContentsFile)">
+      <Output TaskParameter="Lines" ItemName="_BindInputs" />
+    </ReadLinesFromFile>
+
+    <ReadLinesFromFile File="$(IntermediateOutputPath)%(CultureGroup.OutputFolder)$(BindBuiltOutputsFile)">
+      <Output TaskParameter="Lines" ItemName="_BindBuiltOutputs" />
+    </ReadLinesFromFile>
+
+    <Message Importance="low" Text="Previous bind inputs: @(_BindInputs)" />
+    <Message Importance="low" Text="Previous bind outputs: @(_BindBuiltOutputs)" />
+  </Target>
+
+  <!--
+  ================================================================================================
+  Link
+
+    Links the .wixobj, .wxl, .wixlib, wix extensions into an .msi or .msm file using light.exe,
+    once per culture group. All WXL files are passed into light and the culture switch determines
+    which are used
+
+    [IN]
+    @(CompileObjOutput) - The compiled .wixobj file.
+    @(CultureGroup) - The cultures to build
+    @(EmbeddedResource) - The list of wxl files to use for localization.
+    @(WixObject) - The list of .wixobj files.
+    @(WixLibrary) - The list of .wixlib files.
+    @(WixExtension) - The list of wix dll extension files.
+
+    [OUT]
+    $(TargetDir)\%(Culture)\$(TargetName)$(TargetExt) - The compiled .msi, .msm, or .exe files.
+  ================================================================================================
+  -->
+  <PropertyGroup>
+    <LinkDependsOn>
+      PrepareForBuild;
+      ResolveReferences;
+      AssignCultures;
+      ReadPreviousBindInputsAndBuiltOutputs;
+    </LinkDependsOn>
+  </PropertyGroup>
+  <Target
+      Name="Link"
+      Inputs="@(CompileObjOutput);
+              @(EmbeddedResource);
+              @(WixObject);
+              @(_ResolvedProjectReferencePaths);
+              @(_ResolvedWixLibraryPaths);
+              @(_ResolvedWixExtensionPaths);
+              $(MSBuildAllProjects);
+              @(_BindInputs)"
+      Outputs="$(IntermediateOutputPath)%(CultureGroup.OutputFolder)$(BindBuiltOutputsFile);@(_BindBuiltOutputs)"
+      DependsOnTargets="$(LinkDependsOn)"
+      Condition=" '$(OutputType)' == 'Bundle' or '$(OutputType)' == 'Package' or '$(OutputType)' == 'PatchCreation' or '$(OutputType)' == 'Module' ">
+
+    <PropertyGroup>
+      <PdbOutputFile>$(TargetPdbDir)%(CultureGroup.OutputFolder)$(TargetPdbName)</PdbOutputFile>
+    </PropertyGroup>
+
+    <!-- Call light using the culture subdirectory for output -->
+    <Light
+      ObjectFiles="@(CompileObjOutput);@(WixObject);@(WixLibProjects);@(_ResolvedWixLibraryPaths)"
+      AdditionalOptions="$(LinkerAdditionalOptions)"
+      AllowIdenticalRows="$(AllowIdenticalRows)"
+      AllowUnresolvedReferences="$(AllowUnresolvedReferences)"
+      AdditionalCub="$(AdditionalCub)"
+      BackwardsCompatibleGuidGeneration="$(BackwardsCompatibleGuidGeneration)"
+      BindInputPaths="@(LinkerBindInputPaths)"
+      BindFiles="$(LinkerBindFiles)"
+      BindContentsFile="$(IntermediateOutputPath)%(CultureGroup.OutputFolder)$(BindContentsFile)"
+      BindOutputsFile="$(IntermediateOutputPath)%(CultureGroup.OutputFolder)$(BindOutputsFile)"
+      BindBuiltOutputsFile="$(IntermediateOutputPath)%(CultureGroup.OutputFolder)$(BindBuiltOutputsFile)"
+      CabinetCachePath="$(CabinetCachePath)"
+      CabinetCreationThreadCount="$(CabinetCreationThreadCount)"
+      Cultures="%(CultureGroup.Identity)"
+      CustomBinder="$(CustomBinder)"
+      DefaultCompressionLevel="$(DefaultCompressionLevel)"
+      DropUnrealTables="$(DropUnrealTables)"
+      ExactAssemblyVersions="$(ExactAssemblyVersions)"
+      ExtensionDirectory="$(WixExtDir)"
+      Extensions="@(_ResolvedWixExtensionPaths)"
+      Ices="$(Ices)"
+      LeaveTemporaryFiles="$(LeaveTemporaryFiles)"
+      LocalizationFiles="@(EmbeddedResource)"
+      NoLogo="$(LinkerNoLogo)"
+      OutputAsXml="$(OutputAsXml)"
+      OutputFile="$(IntermediateOutputPath)%(CultureGroup.OutputFolder)$(TargetName)$(TargetExt)"
+      PdbOutputFile="$(PdbOutputFile)"
+      Pedantic="$(LinkerPedantic)"
+      ReferencePaths="$(ReferencePaths)"
+      ReuseCabinetCache="$(ReuseCabinetCache)"
+      RunAsSeparateProcess="$(RunWixToolsOutOfProc)"
+      SuppressAclReset="$(SuppressAclReset)"
+      SuppressAllWarnings="$(LinkerSuppressAllWarnings)"
+      SuppressAssemblies="$(SuppressAssemblies)"
+      SuppressDefaultAdminSequenceActions="$(SuppressDefaultAdminSequenceActions)"
+      SuppressDefaultAdvSequenceActions="$(SuppressDefaultAdvSequenceActions)"
+      SuppressDefaultUISequenceActions="$(SuppressDefaultUISequenceActions)"
+      SuppressFileHashAndInfo="$(SuppressFileHashAndInfo)"
+      SuppressFiles="$(SuppressFiles)"
+      SuppressIntermediateFileVersionMatching="$(LinkerSuppressIntermediateFileVersionMatching)"
+      SuppressIces="$(SuppressIces)"
+      SuppressLayout="$(SuppressLayout)"
+      SuppressLocalization="$(SuppressLocalization)"
+      SuppressMsiAssemblyTableProcessing="$(SuppressMsiAssemblyTableProcessing)"
+      SuppressPdbOutput="$(SuppressPdbOutput)"
+      SuppressSchemaValidation="$(LinkerSuppressSchemaValidation)"
+      SuppressValidation="$(SuppressValidation)"
+      SuppressSpecificWarnings="$(LinkerSuppressSpecificWarnings)"
+      SuppressTagSectionIdAttributeOnTuples="$(SuppressTagSectionIdAttributeOnTuples)"
+      ToolPath="$(WixToolDir)"
+      TreatWarningsAsErrors="$(LinkerTreatWarningsAsErrors)"
+      UnreferencedSymbolsFile="$(UnreferencedSymbolsFile)"
+      VerboseOutput="$(LinkerVerboseOutput)"
+      WixProjectFile="$(ProjectPath)"
+      WixVariables="$(WixVariables)" />
+  </Target>
+
+  <!--
+  ================================================================================================
+  UpdateLinkFileWrites
+
+    Reads the bind outputs file(s) output generated during Link to correctly set the @(FileWrites)
+    item. Most targets have it easy because they can do a static mapping from inputs to the outputs.
+    However, the Link target outputs are determined after a rather complex calculation we call
+    linking and binding!
+
+    This target runs independently after Link to ensure that @(FileWrites) is updated even if the
+    "Light" task fails.
+
+    [IN]
+    Path to bind outputs file(s).
+
+    [OUT]
+    @(FileWrites) updated with outputs from bind.
+  ================================================================================================
+  -->
+  <Target
+      Name="UpdateLinkFileWrites"
+      Condition=" '$(OutputType)' == 'Bundle' or '$(OutputType)' == 'Package' or '$(OutputType)' == 'PatchCreation' or '$(OutputType)' == 'Module' ">
+
+    <ReadLinesFromFile File="$(IntermediateOutputPath)%(CultureGroup.OutputFolder)$(BindOutputsFile)">
+      <Output TaskParameter="Lines" ItemName="FileWrites"/>
+    </ReadLinesFromFile>
+
+    <ItemGroup>
+      <FileWrites Include="$(IntermediateOutputPath)%(CultureGroup.OutputFolder)$(BindContentsFile)" />
+      <FileWrites Include="$(IntermediateOutputPath)%(CultureGroup.OutputFolder)$(BindOutputsFile)" />
+      <FileWrites Include="$(IntermediateOutputPath)%(CultureGroup.OutputFolder)$(BindBuiltOutputsFile)" />
+    </ItemGroup>
+
+    <Message Importance="low" Text="Build files after link: @(FileWrites)" />
+  </Target>
+
+  <!--
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  AllProjectOutputGroups Section
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+  -->
+
+  <!--
+  ==================================================================================================
+  AllProjectOutputGroups - OVERRIDE Target
+
+  ==================================================================================================
+  -->
+  <Target
+      Name="AllProjectOutputGroups"
+      DependsOnTargets="
+        BuiltProjectOutputGroup;
+        DebugSymbolsProjectOutputGroup;
+        SourceFilesProjectOutputGroup;
+        ContentFilesProjectOutputGroup" />
+
+  <!-- 
+  This is the key output for the BuiltProjectOutputGroup and is meant to be read directly from the IDE.
+  Reading an item is faster than invoking a target.
+  -->
+  <ItemGroup>
+    <BuiltProjectOutputGroupKeyOutput Include="$(TargetPath)">
+      <IsKeyOutput>true</IsKeyOutput>
+      <FinalOutputPath>$(TargetPath)</FinalOutputPath>
+      <TargetPath>$(TargetFileName)</TargetPath>
+    </BuiltProjectOutputGroupKeyOutput>
+  </ItemGroup>
+
+  <!--
+  ==================================================================================================
+  BuiltProjectOutputGroup - OVERRIDE Target
+  ==================================================================================================
+  -->
+  <PropertyGroup>
+    <BuiltProjectOutputGroupDependsOn>PrepareForBuild;AssignCultures</BuiltProjectOutputGroupDependsOn>
+  </PropertyGroup>
+  <Target
+    Name="BuiltProjectOutputGroup"
+    Outputs="@(BuiltProjectOutputGroupOutput)"
+    DependsOnTargets="$(BuiltProjectOutputGroupDependsOn)">
+
+    <!-- Don't add BuiltProjectOutputGroupKeyOutput - to avoid duplicates, we only want to get the updated list of TargetPaths from the TargetPath property below -->
+
+    <!-- Try to read the outputs from the bind outputs text file since that's the output list straight from linker. -->
+    <ReadLinesFromFile File="$(IntermediateOutputPath)%(CultureGroup.OutputFolder)$(BindOutputsFile)">
+      <Output TaskParameter="Lines" ItemName="_BuiltProjectOutputGroupOutputIntermediate"/>
+    </ReadLinesFromFile>
+
+    <!-- If we didn't get anything from the bind outputs text file, default to the target path. -->
+    <ItemGroup Condition=" '@(_BuiltProjectOutputGroupOutputIntermediate)'=='' ">
+      <_BuiltProjectOutputGroupOutputIntermediate Include="$(TargetPath)" />
+    </ItemGroup>
+
+    <!-- Convert intermediate items into final items; this way we can get the full path for each item -->
+    <ItemGroup>
+      <BuiltProjectOutputGroupOutput Include="@(_BuiltProjectOutputGroupOutputIntermediate->'%(FullPath)')">
+        <!-- For compatibility with 2.0 -->
+        <OriginalItemSpec Condition="'%(_BuiltProjectOutputGroupOutputIntermediate.OriginalItemSpec)' == ''">%(_BuiltProjectOutputGroupOutputIntermediate.FullPath)</OriginalItemSpec>
+      </BuiltProjectOutputGroupOutput>
+    </ItemGroup>
+  </Target>
+
+  <!--
+  ==================================================================================================
+  DebugSymbolsProjectOutputGroup
+
+    Populates the Debug Symbols project output group.
+  ==================================================================================================
+  -->
+  <PropertyGroup>
+    <DebugSymbolsProjectOutputGroupDependsOn>AssignCultures</DebugSymbolsProjectOutputGroupDependsOn>
+  </PropertyGroup>
+  <Target
+    Name="DebugSymbolsProjectOutputGroup"
+    Outputs="@(DebugSymbolsProjectOutputGroupOutput)"
+    DependsOnTargets="$(DebugSymbolsProjectOutputGroupDependsOn)">
+
+    <!-- Include build output pdb(s).  Different than predefined itemgroup since AssignCultures target may change -->
+    <ItemGroup>
+      <DebugSymbolsProjectOutputGroupOutput Include="$(TargetPdbPath)" Condition=" '$(SuppressPdbOutput)' != 'true' "/>
+    </ItemGroup>
+  </Target>
+
+
+  <!--
+  ==================================================================================================
+  CopyFilesToOutputDirectory - OVERRIDE Target
+
+  Copy all build outputs, satellites and other necessary files to the final directory.
+  ============================================================
+  -->
+  <Target
+      Name="CopyFilesToOutputDirectory">
+
+    <PropertyGroup>
+      <!-- By default we're using hard links to copy to the output directory, disabling this could slow the build significantly -->
+      <CreateHardLinksForCopyFilesToOutputDirectoryIfPossible Condition=" '$(CreateHardLinksForCopyFilesToOutputDirectoryIfPossible)' == '' ">true</CreateHardLinksForCopyFilesToOutputDirectoryIfPossible>
+    </PropertyGroup>
+
+    <PropertyGroup>
+      <CopyBuildOutputToOutputDirectory Condition="'$(CopyBuildOutputToOutputDirectory)'==''">true</CopyBuildOutputToOutputDirectory>
+      <CopyOutputSymbolsToOutputDirectory Condition="'$(CopyOutputSymbolsToOutputDirectory)'==''">true</CopyOutputSymbolsToOutputDirectory>
+      <FullIntermediateOutputPath>$([System.IO.Path]::GetFullPath($(IntermediateOutputPath)))</FullIntermediateOutputPath>
+    </PropertyGroup>
+
+    <!-- Copy the bound files. -->
+    <ReadLinesFromFile File="$(IntermediateOutputPath)%(CultureGroup.OutputFolder)$(BindOutputsFile)">
+      <Output TaskParameter="Lines" ItemName="_FullPathToCopy"/>
+    </ReadLinesFromFile>
+
+    <ItemGroup>
+      <_FullPathToCopy Include="$(TargetPath)" Condition=" '@(_FullPathToCopy)'=='' " />
+      <_RelativePath Include="$([MSBuild]::MakeRelative($(FullIntermediateOutputPath), %(_FullPathToCopy.Identity)))" />
+    </ItemGroup>
+
+    <Copy
+        SourceFiles="@(_RelativePath->'$(IntermediateOutputPath)%(Identity)')"
+        DestinationFiles="@(_RelativePath->'$(OutDir)%(Identity)')"
+        SkipUnchangedFiles="$(SkipCopyUnchangedFiles)"
+        OverwriteReadOnlyFiles="$(OverwriteReadOnlyFiles)"
+        Retries="$(CopyRetryCount)"
+        RetryDelayMilliseconds="$(CopyRetryDelayMilliseconds)"
+        UseHardlinksIfPossible="$(CreateHardLinksForCopyFilesToOutputDirectoryIfPossible)"
+        Condition="'$(CopyBuildOutputToOutputDirectory)' == 'true' and '$(SkipCopyBuildProduct)' != 'true'"
+            >
+
+      <Output TaskParameter="DestinationFiles" ItemName="MainAssembly"/>
+      <Output TaskParameter="DestinationFiles" ItemName="FileWrites"/>
+
+    </Copy>
+
+    <Message Importance="High" Text="$(MSBuildProjectName) -&gt; $(TargetPath)" Condition="'$(CopyBuildOutputToOutputDirectory)' == 'true' and '$(SkipCopyBuildProduct)'!='true'" />
+    <!--<Message Importance="High" Text="$(MSBuildProjectName) -&gt; @(MainAssembly->'%(FullPath)')" Condition="'$(CopyBuildOutputToOutputDirectory)' == 'true' and '$(SkipCopyBuildProduct)'!='true'" />-->
+
+    <!-- Copy the debug information file (.pdb), if any
+    <Copy
+        SourceFiles="@(_DebugSymbolsIntermediatePath)"
+        DestinationFiles="@(_DebugSymbolsOutputPath)"
+        SkipUnchangedFiles="$(SkipCopyUnchangedFiles)"
+        OverwriteReadOnlyFiles="$(OverwriteReadOnlyFiles)"
+        Retries="$(CopyRetryCount)"
+        RetryDelayMilliseconds="$(CopyRetryDelayMilliseconds)"
+        UseHardlinksIfPossible="$(CreateHardLinksForCopyFilesToOutputDirectoryIfPossible)"
+        Condition="'$(_DebugSymbolsProduced)'=='true' and '$(SkipCopyingSymbolsToOutputDirectory)' != 'true' and '$(CopyOutputSymbolsToOutputDirectory)'=='true'">
+
+      <Output TaskParameter="DestinationFiles" ItemName="FileWrites"/>
+
+    </Copy>
+    -->
+  </Target>
+
+
+  <Import Project="$(WixHarvestTargetsPath)" Condition=" '$(WixHarvestTargetsPath)' != '' and Exists('$(WixHarvestTargetsPath)')" />
+  <Import Project="$(WixSigningTargetsPath)" Condition=" '$(WixSigningTargetsPath)' != '' and Exists('$(WixSigningTargetsPath)')" />
+  <Import Project="$(LuxTargetsPath)" Condition=" '$(LuxTargetsPath)' != '' and Exists('$(LuxTargetsPath)')" />
+
+  <!-- Extension point: Define CustomAfterWixTargets to a .targets file that you want to include after this file. -->
+  <Import Project="$(CustomAfterWixTargets)" Condition=" '$(CustomAfterWixTargets)' != '' and Exists('$(CustomAfterWixTargets)')" />
+
+</Project>
diff --git a/src/WixToolset.Core/AppCommon.cs b/src/WixToolset.Core/AppCommon.cs
new file mode 100644
index 00000000..30ec7771
--- /dev/null
+++ b/src/WixToolset.Core/AppCommon.cs
@@ -0,0 +1,145 @@
+// 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
+{
+    using System;
+    using System.Collections.Specialized;
+    using System.Configuration;
+    using System.Globalization;
+    using System.IO;
+    using System.Reflection;
+    using System.Text;
+    using System.Threading;
+    using WixToolset.Data;
+
+    /// <summary>
+    /// Common utilities for Wix applications.
+    /// </summary>
+    public static class AppCommon
+    {
+        /// <summary>
+        /// Read the configuration file (*.exe.config).
+        /// </summary>
+        /// <param name="extensions">Extensions to load.</param>
+        public static void ReadConfiguration(StringCollection extensions)
+        {
+            if (null == extensions)
+            {
+                throw new ArgumentNullException("extensions");
+            }
+
+#if REDO_IN_NETCORE
+            // Don't use the default AppSettings reader because
+            // the tool may be called from within another process.
+            // Instead, read the .exe.config file from the tool location.
+            string toolPath = (new System.Uri(Assembly.GetCallingAssembly().CodeBase)).LocalPath;
+            Configuration config = ConfigurationManager.OpenExeConfiguration(toolPath);
+            if (config.HasFile)
+            {
+                KeyValueConfigurationElement configVal = config.AppSettings.Settings["extensions"];
+                if (configVal != null)
+                {
+                    string extensionTypes = configVal.Value;
+                    foreach (string extensionType in extensionTypes.Split(";".ToCharArray()))
+                    {
+                        extensions.Add(extensionType);
+                    }
+                }
+            }
+#endif
+        }
+
+        /// <summary>
+        /// Gets a unique temporary location or uses the provided temporary location.
+        /// </summary>
+        /// <param name="tempLocation">Optional temporary location to use.</param>
+        /// <returns>Temporary location.</returns>
+        public static string GetTempLocation(string tempLocation = null)
+        {
+            if (String.IsNullOrEmpty(tempLocation))
+            {
+                tempLocation = Environment.GetEnvironmentVariable("WIX_TEMP") ?? Path.GetTempPath();
+
+                do
+                {
+                    tempLocation = Path.Combine(tempLocation, DateTime.Now.ToString("wixyyMMddTHHmmssffff"));
+                } while (Directory.Exists(tempLocation));
+            }
+
+            return tempLocation;
+        }
+
+        /// <summary>
+        /// Delete a directory with retries and best-effort cleanup.
+        /// </summary>
+        /// <param name="path">The directory to delete.</param>
+        /// <param name="messageHandler">The message handler.</param>
+        /// <returns>True if all files were deleted, false otherwise.</returns>
+        public static bool DeleteDirectory(string path, IMessageHandler messageHandler)
+        {
+            return Common.DeleteTempFiles(path, messageHandler);
+        }
+
+        /// <summary>
+        /// Prepares the console for localization.
+        /// </summary>
+        public static void PrepareConsoleForLocalization()
+        {
+            Thread.CurrentThread.CurrentUICulture = CultureInfo.CurrentUICulture.GetConsoleFallbackUICulture();
+            if ((Console.OutputEncoding.CodePage != Encoding.UTF8.CodePage) &&
+                (Console.OutputEncoding.CodePage != Thread.CurrentThread.CurrentUICulture.TextInfo.OEMCodePage) &&
+                (Console.OutputEncoding.CodePage != Thread.CurrentThread.CurrentUICulture.TextInfo.ANSICodePage))
+            {
+                Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-US");
+            }
+        }
+
+        /// <summary>
+        /// Handler for display message events.
+        /// </summary>
+        /// <param name="sender">Sender of message.</param>
+        /// <param name="e">Event arguments containing message to display.</param>
+        public static void ConsoleDisplayMessage(object sender, DisplayEventArgs e)
+        {
+            switch (e.Level)
+            {
+                case MessageLevel.Warning:
+                case MessageLevel.Error:
+                    Console.Error.WriteLine(e.Message);
+                    break;
+                default:
+                    Console.WriteLine(e.Message);
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// Creates and returns the string for CreatingApplication field (MSI Summary Information Stream).
+        /// </summary>
+        /// <remarks>It reads the AssemblyProductAttribute and AssemblyVersionAttribute of executing assembly
+        /// and builds the CreatingApplication string of the form "[ProductName] ([ProductVersion])".</remarks>
+        /// <returns>Returns value for PID_APPNAME."</returns>
+        public static string GetCreatingApplicationString()
+        {
+            Assembly assembly = Assembly.GetExecutingAssembly();
+            return WixDistribution.ReplacePlaceholders("[AssemblyProduct] ([FileVersion])", assembly);
+        }
+
+        /// <summary>
+        /// Displays help message header on Console for caller tool.
+        /// </summary>
+        public static void DisplayToolHeader()
+        {
+            Assembly assembly = Assembly.GetCallingAssembly();
+            Console.WriteLine(WixDistribution.ReplacePlaceholders(WixDistributionSpecificStrings.ToolsetHelpHeader, assembly));
+        }
+
+        /// <summary>
+        /// Displays help message header on Console for caller tool.
+        /// </summary>
+        public static void DisplayToolFooter()
+        {
+            Console.Write(WixDistribution.ReplacePlaceholders(WixDistributionSpecificStrings.ToolsetHelpFooter, null));
+        }
+    }
+}
diff --git a/src/WixToolset.Core/AssemblyInfo.cs b/src/WixToolset.Core/AssemblyInfo.cs
new file mode 100644
index 00000000..b3740b2a
--- /dev/null
+++ b/src/WixToolset.Core/AssemblyInfo.cs
@@ -0,0 +1,9 @@
+// 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.
+
+using System;
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+[assembly: AssemblyCulture("")]
+[assembly: CLSCompliant(true)]
+[assembly: ComVisible(false)]
diff --git a/src/WixToolset.Core/Bind/BindBundleCommand.cs b/src/WixToolset.Core/Bind/BindBundleCommand.cs
new file mode 100644
index 00000000..7ea0c830
--- /dev/null
+++ b/src/WixToolset.Core/Bind/BindBundleCommand.cs
@@ -0,0 +1,905 @@
+// 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.Bind
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Globalization;
+    using System.IO;
+    using System.Linq;
+    using System.Reflection;
+    using WixToolset.Bind.Bundles;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+    using WixToolset.Extensibility;
+
+    /// <summary>
+    /// Binds a this.bundle.
+    /// </summary>
+    internal class BindBundleCommand : ICommand
+    {
+        public CompressionLevel DefaultCompressionLevel { private get; set; }
+
+        public IEnumerable<IBinderExtension> Extensions { private get; set; }
+
+        public BinderFileManagerCore FileManagerCore { private get; set; }
+
+        public IEnumerable<IBinderFileManager> FileManagers { private get; set; }
+
+        public Output Output { private get; set; }
+
+        public string OutputPath { private get; set; }
+
+        public string PdbFile { private get; set; }
+
+        public TableDefinitionCollection TableDefinitions { private get; set; }
+
+        public string TempFilesLocation { private get; set; }
+
+        public WixVariableResolver WixVariableResolver { private get; set; }
+
+        public IEnumerable<FileTransfer> FileTransfers { get; private set; }
+
+        public IEnumerable<string> ContentFilePaths { get; private set; }
+
+        public void Execute()
+        {
+            this.FileTransfers = Enumerable.Empty<FileTransfer>();
+            this.ContentFilePaths = Enumerable.Empty<string>();
+
+            // First look for data we expect to find... Chain, WixGroups, etc.
+
+            // We shouldn't really get past the linker phase if there are
+            // no group items... that means that there's no UX, no Chain,
+            // *and* no Containers!
+            Table chainPackageTable = this.GetRequiredTable("WixBundlePackage");
+
+            Table wixGroupTable = this.GetRequiredTable("WixGroup");
+
+            // Ensure there is one and only one row in the WixBundle table.
+            // The compiler and linker behavior should have colluded to get
+            // this behavior.
+            WixBundleRow bundleRow = (WixBundleRow)this.GetSingleRowTable("WixBundle");
+
+            bundleRow.PerMachine = true; // default to per-machine but the first-per user package wil flip the bundle per-user.
+
+            // Ensure there is one and only one row in the WixBootstrapperApplication table.
+            // The compiler and linker behavior should have colluded to get
+            // this behavior.
+            Row baRow = this.GetSingleRowTable("WixBootstrapperApplication");
+
+            // Ensure there is one and only one row in the WixChain table.
+            // The compiler and linker behavior should have colluded to get
+            // this behavior.
+            WixChainRow chainRow = (WixChainRow)this.GetSingleRowTable("WixChain");
+
+            if (Messaging.Instance.EncounteredError)
+            {
+                return;
+            }
+
+            // Localize fields, resolve wix variables, and resolve file paths.
+            ExtractEmbeddedFiles filesWithEmbeddedFiles = new ExtractEmbeddedFiles();
+
+            IEnumerable<DelayedField> delayedFields;
+            {
+                ResolveFieldsCommand command = new ResolveFieldsCommand();
+                command.Tables = this.Output.Tables;
+                command.FilesWithEmbeddedFiles = filesWithEmbeddedFiles;
+                command.FileManagerCore = this.FileManagerCore;
+                command.FileManagers = this.FileManagers;
+                command.SupportDelayedResolution = true;
+                command.TempFilesLocation = this.TempFilesLocation;
+                command.WixVariableResolver = this.WixVariableResolver;
+                command.Execute();
+
+                delayedFields = command.DelayedFields;
+            }
+
+            if (Messaging.Instance.EncounteredError)
+            {
+                return;
+            }
+
+            // If there are any fields to resolve later, create the cache to populate during bind.
+            IDictionary<string, string> variableCache = null;
+            if (delayedFields.Any())
+            {
+                variableCache = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase);
+            }
+
+            // TODO: Although the WixSearch tables are defined in the Util extension,
+            // the Bundle Binder has to know all about them. We hope to revisit all
+            // of this in the 4.0 timeframe.
+            IEnumerable<WixSearchInfo> orderedSearches = this.OrderSearches();
+
+            // Extract files that come from cabinet files (this does not extract files from merge modules).
+            {
+                ExtractEmbeddedFilesCommand extractEmbeddedFilesCommand = new ExtractEmbeddedFilesCommand();
+                extractEmbeddedFilesCommand.FilesWithEmbeddedFiles = filesWithEmbeddedFiles;
+                extractEmbeddedFilesCommand.Execute();
+            }
+
+            // Get the explicit payloads.
+            RowDictionary<WixBundlePayloadRow> payloads = new RowDictionary<WixBundlePayloadRow>(this.Output.Tables["WixBundlePayload"]);
+
+            // Update explicitly authored payloads with their parent package and container (as appropriate)
+            // to make it easier to gather the payloads later.
+            foreach (WixGroupRow row in wixGroupTable.RowsAs<WixGroupRow>())
+            {
+                if (ComplexReferenceChildType.Payload == row.ChildType)
+                {
+                    WixBundlePayloadRow payload = payloads.Get(row.ChildId);
+
+                    if (ComplexReferenceParentType.Package == row.ParentType)
+                    {
+                        Debug.Assert(String.IsNullOrEmpty(payload.Package));
+                        payload.Package = row.ParentId;
+                    }
+                    else if (ComplexReferenceParentType.Container == row.ParentType)
+                    {
+                        Debug.Assert(String.IsNullOrEmpty(payload.Container));
+                        payload.Container = row.ParentId;
+                    }
+                    else if (ComplexReferenceParentType.Layout == row.ParentType)
+                    {
+                        payload.LayoutOnly = true;
+                    }
+                }
+            }
+
+            List<FileTransfer> fileTransfers = new List<FileTransfer>();
+            string layoutDirectory = Path.GetDirectoryName(this.OutputPath);
+
+            // Process the explicitly authored payloads.
+            ISet<string> processedPayloads;
+            {
+                ProcessPayloadsCommand command = new ProcessPayloadsCommand();
+                command.Payloads = payloads.Values;
+                command.DefaultPackaging = bundleRow.DefaultPackagingType;
+                command.LayoutDirectory = layoutDirectory;
+                command.Execute();
+
+                fileTransfers.AddRange(command.FileTransfers);
+
+                processedPayloads = new HashSet<string>(payloads.Keys);
+            }
+
+            IDictionary<string, PackageFacade> facades;
+            {
+                GetPackageFacadesCommand command = new GetPackageFacadesCommand();
+                command.PackageTable = chainPackageTable;
+                command.ExePackageTable = this.Output.Tables["WixBundleExePackage"];
+                command.MsiPackageTable = this.Output.Tables["WixBundleMsiPackage"];
+                command.MspPackageTable = this.Output.Tables["WixBundleMspPackage"];
+                command.MsuPackageTable = this.Output.Tables["WixBundleMsuPackage"];
+                command.Execute();
+
+                facades = command.PackageFacades;
+            }
+
+            // Process each package facade. Note this is likely to add payloads and other rows to tables so
+            // note that any indexes created above may be out of date now.
+            foreach (PackageFacade facade in facades.Values)
+            {
+                switch (facade.Package.Type)
+                {
+                    case WixBundlePackageType.Exe:
+                        {
+                            ProcessExePackageCommand command = new ProcessExePackageCommand();
+                            command.AuthoredPayloads = payloads;
+                            command.Facade = facade;
+                            command.Execute();
+
+                           // ? variableCache.Add(String.Concat("packageManufacturer.", facade.Package.WixChainItemId), facade.ExePackage.Manufacturer);
+                        }
+                        break;
+
+                    case WixBundlePackageType.Msi:
+                        {
+                            ProcessMsiPackageCommand command = new ProcessMsiPackageCommand();
+                            command.AuthoredPayloads = payloads;
+                            command.Facade = facade;
+                            command.FileManager = this.FileManagers.First();
+                            command.MsiFeatureTable = this.Output.EnsureTable(this.TableDefinitions["WixBundleMsiFeature"]);
+                            command.MsiPropertyTable = this.Output.EnsureTable(this.TableDefinitions["WixBundleMsiProperty"]);
+                            command.PayloadTable = this.Output.Tables["WixBundlePayload"];
+                            command.RelatedPackageTable = this.Output.EnsureTable(this.TableDefinitions["WixBundleRelatedPackage"]);
+                            command.Execute();
+
+                            if (null != variableCache)
+                            {
+                                variableCache.Add(String.Concat("packageLanguage.", facade.Package.WixChainItemId), facade.MsiPackage.ProductLanguage.ToString());
+
+                                if (null != facade.MsiPackage.Manufacturer)
+                                {
+                                    variableCache.Add(String.Concat("packageManufacturer.", facade.Package.WixChainItemId), facade.MsiPackage.Manufacturer);
+                                }
+                            }
+
+                        }
+                        break;
+
+                    case WixBundlePackageType.Msp:
+                        {
+                            ProcessMspPackageCommand command = new ProcessMspPackageCommand();
+                            command.AuthoredPayloads = payloads;
+                            command.Facade = facade;
+                            command.WixBundlePatchTargetCodeTable = this.Output.EnsureTable(this.TableDefinitions["WixBundlePatchTargetCode"]);
+                            command.Execute();
+                        }
+                        break;
+
+                    case WixBundlePackageType.Msu:
+                        {
+                            ProcessMsuPackageCommand command = new ProcessMsuPackageCommand();
+                            command.Facade = facade;
+                            command.Execute();
+                        }
+                        break;
+                }
+
+                if (null != variableCache)
+                {
+                    BindBundleCommand.PopulatePackageVariableCache(facade.Package, variableCache);
+                }
+            }
+
+            // Reindex the payloads now that all the payloads (minus the manifest payloads that will be created later)
+            // are present.
+            payloads = new RowDictionary<WixBundlePayloadRow>(this.Output.Tables["WixBundlePayload"]);
+
+            // Process the payloads that were added by processing the packages.
+            {
+                ProcessPayloadsCommand command = new ProcessPayloadsCommand();
+                command.Payloads = payloads.Values.Where(r => !processedPayloads.Contains(r.Id)).ToList();
+                command.DefaultPackaging = bundleRow.DefaultPackagingType;
+                command.LayoutDirectory = layoutDirectory;
+                command.Execute();
+
+                fileTransfers.AddRange(command.FileTransfers);
+
+                processedPayloads = null;
+            }
+
+            // Set the package metadata from the payloads now that we have the complete payload information.
+            ILookup<string, WixBundlePayloadRow> payloadsByPackage = payloads.Values.ToLookup(p => p.Package);
+
+            {
+                foreach (PackageFacade facade in facades.Values)
+                {
+                    facade.Package.Size = 0;
+
+                    IEnumerable<WixBundlePayloadRow> packagePayloads = payloadsByPackage[facade.Package.WixChainItemId];
+
+                    foreach (WixBundlePayloadRow payload in packagePayloads)
+                    {
+                        facade.Package.Size += payload.FileSize;
+                    }
+
+                    if (!facade.Package.InstallSize.HasValue)
+                    {
+                        facade.Package.InstallSize = facade.Package.Size;
+
+                    }
+
+                    WixBundlePayloadRow packagePayload = payloads[facade.Package.PackagePayload];
+
+                    if (String.IsNullOrEmpty(facade.Package.Description))
+                    {
+                        facade.Package.Description = packagePayload.Description;
+                    }
+
+                    if (String.IsNullOrEmpty(facade.Package.DisplayName))
+                    {
+                        facade.Package.DisplayName = packagePayload.DisplayName;
+                    }
+                }
+            }
+
+
+            // Give the UX payloads their embedded IDs...
+            int uxPayloadIndex = 0;
+            {
+                foreach (WixBundlePayloadRow payload in payloads.Values.Where(p => Compiler.BurnUXContainerId == p.Container))
+                {
+                    // In theory, UX payloads could be embedded in the UX CAB, external to the bundle EXE, or even
+                    // downloaded. The current engine requires the UX to be fully present before any downloading starts,
+                    // so that rules out downloading. Also, the burn engine does not currently copy external UX payloads
+                    // into the temporary UX directory correctly, so we don't allow external either.
+                    if (PackagingType.Embedded != payload.Packaging)
+                    {
+                        Messaging.Instance.OnMessage(WixWarnings.UxPayloadsOnlySupportEmbedding(payload.SourceLineNumbers, payload.FullFileName));
+                        payload.Packaging = PackagingType.Embedded;
+                    }
+
+                    payload.EmbeddedId = String.Format(CultureInfo.InvariantCulture, BurnCommon.BurnUXContainerEmbeddedIdFormat, uxPayloadIndex);
+                    ++uxPayloadIndex;
+                }
+
+                if (0 == uxPayloadIndex)
+                {
+                    // If we didn't get any UX payloads, it's an error!
+                    throw new WixException(WixErrors.MissingBundleInformation("BootstrapperApplication"));
+                }
+
+                // Give the embedded payloads without an embedded id yet an embedded id.
+                int payloadIndex = 0;
+                foreach (WixBundlePayloadRow payload in payloads.Values)
+                {
+                    Debug.Assert(PackagingType.Unknown != payload.Packaging);
+
+                    if (PackagingType.Embedded == payload.Packaging && String.IsNullOrEmpty(payload.EmbeddedId))
+                    {
+                        payload.EmbeddedId = String.Format(CultureInfo.InvariantCulture, BurnCommon.BurnAttachedContainerEmbeddedIdFormat, payloadIndex);
+                        ++payloadIndex;
+                    }
+                }
+            }
+
+            // Determine patches to automatically slipstream.
+            {
+                AutomaticallySlipstreamPatchesCommand command = new AutomaticallySlipstreamPatchesCommand();
+                command.PackageFacades = facades.Values;
+                command.SlipstreamMspTable = this.Output.EnsureTable(this.TableDefinitions["WixBundleSlipstreamMsp"]);
+                command.WixBundlePatchTargetCodeTable = this.Output.EnsureTable(this.TableDefinitions["WixBundlePatchTargetCode"]);
+                command.Execute();
+            }
+
+            // If catalog files exist, non-embedded payloads should validate with the catalogs.
+            IEnumerable<WixBundleCatalogRow> catalogs = this.Output.Tables["WixBundleCatalog"].RowsAs<WixBundleCatalogRow>();
+
+            if (catalogs.Any())
+            {
+                VerifyPayloadsWithCatalogCommand command = new VerifyPayloadsWithCatalogCommand();
+                command.Catalogs = catalogs;
+                command.Payloads = payloads.Values;
+                command.Execute();
+            }
+
+            if (Messaging.Instance.EncounteredError)
+            {
+                return;
+            }
+
+            IEnumerable<PackageFacade> orderedFacades;
+            IEnumerable<WixBundleRollbackBoundaryRow> boundaries;
+            {
+                OrderPackagesAndRollbackBoundariesCommand command = new OrderPackagesAndRollbackBoundariesCommand();
+                command.Boundaries = new RowDictionary<WixBundleRollbackBoundaryRow>(this.Output.Tables["WixBundleRollbackBoundary"]);
+                command.PackageFacades = facades;
+                command.WixGroupTable = wixGroupTable;
+                command.Execute();
+
+                orderedFacades = command.OrderedPackageFacades;
+                boundaries = command.UsedRollbackBoundaries;
+            }
+
+            // Resolve any delayed fields before generating the manifest.
+            if (delayedFields.Any())
+            {
+                ResolveDelayedFieldsCommand resolveDelayedFieldsCommand = new ResolveDelayedFieldsCommand();
+                resolveDelayedFieldsCommand.OutputType = this.Output.Type;
+                resolveDelayedFieldsCommand.DelayedFields = delayedFields;
+                resolveDelayedFieldsCommand.ModularizationGuid = null;
+                resolveDelayedFieldsCommand.VariableCache = variableCache;
+                resolveDelayedFieldsCommand.Execute();
+            }
+
+            // Set the overridable bundle provider key.
+            this.SetBundleProviderKey(this.Output, bundleRow);
+
+            // Import or generate dependency providers for packages in the manifest.
+            this.ProcessDependencyProviders(this.Output, facades);
+
+            // Update the bundle per-machine/per-user scope based on the chained packages.
+            this.ResolveBundleInstallScope(bundleRow, orderedFacades);
+
+            // Generate the core-defined BA manifest tables...
+            {
+                CreateBootstrapperApplicationManifestCommand command = new CreateBootstrapperApplicationManifestCommand();
+                command.BundleRow = bundleRow;
+                command.ChainPackages = orderedFacades;
+                command.LastUXPayloadIndex = uxPayloadIndex;
+                command.MsiFeatures = this.Output.Tables["WixBundleMsiFeature"].RowsAs<WixBundleMsiFeatureRow>();
+                command.Output = this.Output;
+                command.Payloads = payloads;
+                command.TableDefinitions = this.TableDefinitions;
+                command.TempFilesLocation = this.TempFilesLocation;
+                command.Execute();
+
+                WixBundlePayloadRow baManifestPayload = command.BootstrapperApplicationManifestPayloadRow;
+                payloads.Add(baManifestPayload);
+            }
+
+            foreach (BinderExtension extension in this.Extensions)
+            {
+                extension.Finish(Output);
+            }
+
+            // Create all the containers except the UX container first so the manifest (that goes in the UX container)
+            // can contain all size and hash information about the non-UX containers.
+            RowDictionary<WixBundleContainerRow> containers = new RowDictionary<WixBundleContainerRow>(this.Output.Tables["WixBundleContainer"]);
+
+            ILookup<string, WixBundlePayloadRow> payloadsByContainer = payloads.Values.ToLookup(p => p.Container);
+
+            int attachedContainerIndex = 1; // count starts at one because UX container is "0".
+
+            IEnumerable<WixBundlePayloadRow> uxContainerPayloads = Enumerable.Empty<WixBundlePayloadRow>();
+
+            foreach (WixBundleContainerRow container in containers.Values)
+            {
+                IEnumerable<WixBundlePayloadRow> containerPayloads = payloadsByContainer[container.Id];
+
+                if (!containerPayloads.Any())
+                {
+                    if (container.Id != Compiler.BurnDefaultAttachedContainerId)
+                    {
+                        // TODO: display warning that we're ignoring container that ended up with no paylods in it.
+                    }
+                }
+                else if (Compiler.BurnUXContainerId == container.Id)
+                {
+                    container.WorkingPath = Path.Combine(this.TempFilesLocation, container.Name);
+                    container.AttachedContainerIndex = 0;
+
+                    // Gather the list of UX payloads but ensure the BootstrapperApplication Payload is the first
+                    // in the list since that is the Payload that Burn attempts to load.
+                    List<WixBundlePayloadRow> uxPayloads = new List<WixBundlePayloadRow>();
+
+                    string baPayloadId = baRow.FieldAsString(0);
+
+                    foreach (WixBundlePayloadRow uxPayload in containerPayloads)
+                    {
+                        if (uxPayload.Id == baPayloadId)
+                        {
+                            uxPayloads.Insert(0, uxPayload);
+                        }
+                        else
+                        {
+                            uxPayloads.Add(uxPayload);
+                        }
+                    }
+
+                    uxContainerPayloads = uxPayloads;
+                }
+                else
+                {
+                    container.WorkingPath = Path.Combine(this.TempFilesLocation, container.Name);
+
+                    // Add detached containers to the list of file transfers.
+                    if (ContainerType.Detached == container.Type)
+                    {
+                        FileTransfer transfer;
+                        if (FileTransfer.TryCreate(container.WorkingPath, Path.Combine(layoutDirectory, container.Name), true, "Container", container.SourceLineNumbers, out transfer))
+                        {
+                            transfer.Built = true;
+                            fileTransfers.Add(transfer);
+                        }
+                    }
+                    else // update the attached container index.
+                    {
+                        Debug.Assert(ContainerType.Attached == container.Type);
+
+                        container.AttachedContainerIndex = attachedContainerIndex;
+                        ++attachedContainerIndex;
+                    }
+
+                    this.CreateContainer(container, containerPayloads, null);
+                }
+            }
+
+            // Create the bundle manifest then UX container.
+            string manifestPath = Path.Combine(this.TempFilesLocation, "bundle-manifest.xml");
+            {
+                CreateBurnManifestCommand command = new CreateBurnManifestCommand();
+                command.FileManagers = this.FileManagers;
+                command.Output = this.Output;
+
+                command.BundleInfo = bundleRow;
+                command.Chain = chainRow;
+                command.Containers = containers;
+                command.Catalogs = catalogs;
+                command.ExecutableName = Path.GetFileName(this.OutputPath);
+                command.OrderedPackages = orderedFacades;
+                command.OutputPath = manifestPath;
+                command.RollbackBoundaries = boundaries;
+                command.OrderedSearches = orderedSearches;
+                command.Payloads = payloads;
+                command.UXContainerPayloads = uxContainerPayloads;
+                command.Execute();
+            }
+
+            WixBundleContainerRow uxContainer = containers[Compiler.BurnUXContainerId];
+            this.CreateContainer(uxContainer, uxContainerPayloads, manifestPath);
+
+            // Copy the burn.exe to a writable location then mark it to be moved to its final build location. Note
+            // that today, the x64 Burn uses the x86 stub.
+            string stubPlatform = (Platform.X64 == bundleRow.Platform) ? "x86" : bundleRow.Platform.ToString();
+
+            string stubFile = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), stubPlatform, "burn.exe");
+            string bundleTempPath = Path.Combine(this.TempFilesLocation, Path.GetFileName(this.OutputPath));
+
+            Messaging.Instance.OnMessage(WixVerboses.GeneratingBundle(bundleTempPath, stubFile));
+
+            string bundleFilename = Path.GetFileName(this.OutputPath);
+            if ("setup.exe".Equals(bundleFilename, StringComparison.OrdinalIgnoreCase))
+            {
+                Messaging.Instance.OnMessage(WixErrors.InsecureBundleFilename(bundleFilename));
+            }
+
+            FileTransfer bundleTransfer;
+            if (FileTransfer.TryCreate(bundleTempPath, this.OutputPath, true, "Bundle", bundleRow.SourceLineNumbers, out bundleTransfer))
+            {
+                bundleTransfer.Built = true;
+                fileTransfers.Add(bundleTransfer);
+            }
+
+            File.Copy(stubFile, bundleTempPath, true);
+            File.SetAttributes(bundleTempPath, FileAttributes.Normal);
+
+            this.UpdateBurnResources(bundleTempPath, this.OutputPath, bundleRow);
+
+            // Update the .wixburn section to point to at the UX and attached container(s) then attach the containers
+            // if they should be attached.
+            using (BurnWriter writer = BurnWriter.Open(bundleTempPath))
+            {
+                FileInfo burnStubFile = new FileInfo(bundleTempPath);
+                writer.InitializeBundleSectionData(burnStubFile.Length, bundleRow.BundleId);
+
+                // Always attach the UX container first
+                writer.AppendContainer(uxContainer.WorkingPath, BurnWriter.Container.UX);
+
+                // Now append all other attached containers
+                foreach (WixBundleContainerRow container in containers.Values)
+                {
+                    if (ContainerType.Attached == container.Type)
+                    {
+                        // The container was only created if it had payloads.
+                        if (!String.IsNullOrEmpty(container.WorkingPath) && Compiler.BurnUXContainerId != container.Id)
+                        {
+                            writer.AppendContainer(container.WorkingPath, BurnWriter.Container.Attached);
+                        }
+                    }
+                }
+            }
+
+            if (null != this.PdbFile)
+            {
+                Pdb pdb = new Pdb();
+                pdb.Output = Output;
+                pdb.Save(this.PdbFile);
+            }
+
+            this.FileTransfers = fileTransfers;
+            this.ContentFilePaths = payloads.Values.Where(p => p.ContentFile).Select(p => p.FullFileName).ToList();
+        }
+
+        private Table GetRequiredTable(string tableName)
+        {
+            Table table = this.Output.Tables[tableName];
+            if (null == table || 0 == table.Rows.Count)
+            {
+                throw new WixException(WixErrors.MissingBundleInformation(tableName));
+            }
+
+            return table;
+        }
+
+        private Row GetSingleRowTable(string tableName)
+        {
+            Table table = this.Output.Tables[tableName];
+            if (null == table || 1 != table.Rows.Count)
+            {
+                throw new WixException(WixErrors.MissingBundleInformation(tableName));
+            }
+
+            return table.Rows[0];
+        }
+
+        private List<WixSearchInfo> OrderSearches()
+        {
+            Dictionary<string, WixSearchInfo> allSearches = new Dictionary<string, WixSearchInfo>();
+            Table wixFileSearchTable = this.Output.Tables["WixFileSearch"];
+            if (null != wixFileSearchTable && 0 < wixFileSearchTable.Rows.Count)
+            {
+                foreach (Row row in wixFileSearchTable.Rows)
+                {
+                    WixFileSearchInfo fileSearchInfo = new WixFileSearchInfo(row);
+                    allSearches.Add(fileSearchInfo.Id, fileSearchInfo);
+                }
+            }
+
+            Table wixRegistrySearchTable = this.Output.Tables["WixRegistrySearch"];
+            if (null != wixRegistrySearchTable && 0 < wixRegistrySearchTable.Rows.Count)
+            {
+                foreach (Row row in wixRegistrySearchTable.Rows)
+                {
+                    WixRegistrySearchInfo registrySearchInfo = new WixRegistrySearchInfo(row);
+                    allSearches.Add(registrySearchInfo.Id, registrySearchInfo);
+                }
+            }
+
+            Table wixComponentSearchTable = this.Output.Tables["WixComponentSearch"];
+            if (null != wixComponentSearchTable && 0 < wixComponentSearchTable.Rows.Count)
+            {
+                foreach (Row row in wixComponentSearchTable.Rows)
+                {
+                    WixComponentSearchInfo componentSearchInfo = new WixComponentSearchInfo(row);
+                    allSearches.Add(componentSearchInfo.Id, componentSearchInfo);
+                }
+            }
+
+            Table wixProductSearchTable = this.Output.Tables["WixProductSearch"];
+            if (null != wixProductSearchTable && 0 < wixProductSearchTable.Rows.Count)
+            {
+                foreach (Row row in wixProductSearchTable.Rows)
+                {
+                    WixProductSearchInfo productSearchInfo = new WixProductSearchInfo(row);
+                    allSearches.Add(productSearchInfo.Id, productSearchInfo);
+                }
+            }
+
+            // Merge in the variable/condition info and get the canonical ordering for
+            // the searches.
+            List<WixSearchInfo> orderedSearches = new List<WixSearchInfo>();
+            Table wixSearchTable = this.Output.Tables["WixSearch"];
+            if (null != wixSearchTable && 0 < wixSearchTable.Rows.Count)
+            {
+                orderedSearches.Capacity = wixSearchTable.Rows.Count;
+                foreach (Row row in wixSearchTable.Rows)
+                {
+                    WixSearchInfo searchInfo = allSearches[(string)row[0]];
+                    searchInfo.AddWixSearchRowInfo(row);
+                    orderedSearches.Add(searchInfo);
+                }
+            }
+
+            return orderedSearches;
+        }
+
+        /// <summary>
+        /// Populates the variable cache with specific package properties.
+        /// </summary>
+        /// <param name="package">The package with properties to cache.</param>
+        /// <param name="variableCache">The property cache.</param>
+        private static void PopulatePackageVariableCache(WixBundlePackageRow package, IDictionary<string, string> variableCache)
+        {
+            string id = package.WixChainItemId;
+
+            variableCache.Add(String.Concat("packageDescription.", id), package.Description);
+            //variableCache.Add(String.Concat("packageLanguage.", id), package.Language);
+            //variableCache.Add(String.Concat("packageManufacturer.", id), package.Manufacturer);
+            variableCache.Add(String.Concat("packageName.", id), package.DisplayName);
+            variableCache.Add(String.Concat("packageVersion.", id), package.Version);
+        }
+
+        private void CreateContainer(WixBundleContainerRow container, IEnumerable<WixBundlePayloadRow> containerPayloads, string manifestFile)
+        {
+            CreateContainerCommand command = new CreateContainerCommand();
+            command.DefaultCompressionLevel = this.DefaultCompressionLevel;
+            command.Payloads = containerPayloads;
+            command.ManifestFile = manifestFile;
+            command.OutputPath = container.WorkingPath;
+            command.Execute();
+
+            container.Hash = command.Hash;
+            container.Size = command.Size;
+        }
+
+        private void ResolveBundleInstallScope(WixBundleRow bundleInfo, IEnumerable<PackageFacade> facades)
+        {
+            foreach (PackageFacade facade in facades)
+            {
+                if (bundleInfo.PerMachine && YesNoDefaultType.No == facade.Package.PerMachine)
+                {
+                    Messaging.Instance.OnMessage(WixVerboses.SwitchingToPerUserPackage(facade.Package.SourceLineNumbers, facade.Package.WixChainItemId));
+
+                    bundleInfo.PerMachine = false;
+                    break;
+                }
+            }
+
+            foreach (PackageFacade facade in facades)
+            {
+                // Update package scope from bundle scope if default.
+                if (YesNoDefaultType.Default == facade.Package.PerMachine)
+                {
+                    facade.Package.PerMachine = bundleInfo.PerMachine ? YesNoDefaultType.Yes : YesNoDefaultType.No;
+                }
+
+                // We will only register packages in the same scope as the bundle. Warn if any packages with providers
+                // are in a different scope and not permanent (permanents typically don't need a ref-count).
+                if (!bundleInfo.PerMachine && YesNoDefaultType.Yes == facade.Package.PerMachine && !facade.Package.Permanent && 0 < facade.Provides.Count)
+                {
+                    Messaging.Instance.OnMessage(WixWarnings.NoPerMachineDependencies(facade.Package.SourceLineNumbers, facade.Package.WixChainItemId));
+                }
+            }
+        }
+
+        private void UpdateBurnResources(string bundleTempPath, string outputPath, WixBundleRow bundleInfo)
+        {
+            WixToolset.Dtf.Resources.ResourceCollection resources = new WixToolset.Dtf.Resources.ResourceCollection();
+            WixToolset.Dtf.Resources.VersionResource version = new WixToolset.Dtf.Resources.VersionResource("#1", 1033);
+
+            version.Load(bundleTempPath);
+            resources.Add(version);
+
+            // Ensure the bundle info provides a full four part version.
+            Version fourPartVersion = new Version(bundleInfo.Version);
+            int major = (fourPartVersion.Major < 0) ? 0 : fourPartVersion.Major;
+            int minor = (fourPartVersion.Minor < 0) ? 0 : fourPartVersion.Minor;
+            int build = (fourPartVersion.Build < 0) ? 0 : fourPartVersion.Build;
+            int revision = (fourPartVersion.Revision < 0) ? 0 : fourPartVersion.Revision;
+
+            if (UInt16.MaxValue < major || UInt16.MaxValue < minor || UInt16.MaxValue < build || UInt16.MaxValue < revision)
+            {
+                throw new WixException(WixErrors.InvalidModuleOrBundleVersion(bundleInfo.SourceLineNumbers, "Bundle", bundleInfo.Version));
+            }
+
+            fourPartVersion = new Version(major, minor, build, revision);
+            version.FileVersion = fourPartVersion;
+            version.ProductVersion = fourPartVersion;
+
+            WixToolset.Dtf.Resources.VersionStringTable strings = version[1033];
+            strings["LegalCopyright"] = bundleInfo.Copyright;
+            strings["OriginalFilename"] = Path.GetFileName(outputPath);
+            strings["FileVersion"] = bundleInfo.Version;    // string versions do not have to be four parts.
+            strings["ProductVersion"] = bundleInfo.Version; // string versions do not have to be four parts.
+
+            if (!String.IsNullOrEmpty(bundleInfo.Name))
+            {
+                strings["ProductName"] = bundleInfo.Name;
+                strings["FileDescription"] = bundleInfo.Name;
+            }
+
+            if (!String.IsNullOrEmpty(bundleInfo.Publisher))
+            {
+                strings["CompanyName"] = bundleInfo.Publisher;
+            }
+            else
+            {
+                strings["CompanyName"] = String.Empty;
+            }
+
+            if (!String.IsNullOrEmpty(bundleInfo.IconPath))
+            {
+                Dtf.Resources.GroupIconResource iconGroup = new Dtf.Resources.GroupIconResource("#1", 1033);
+                iconGroup.ReadFromFile(bundleInfo.IconPath);
+                resources.Add(iconGroup);
+
+                foreach (Dtf.Resources.Resource icon in iconGroup.Icons)
+                {
+                    resources.Add(icon);
+                }
+            }
+
+            if (!String.IsNullOrEmpty(bundleInfo.SplashScreenBitmapPath))
+            {
+                Dtf.Resources.BitmapResource bitmap = new Dtf.Resources.BitmapResource("#1", 1033);
+                bitmap.ReadFromFile(bundleInfo.SplashScreenBitmapPath);
+                resources.Add(bitmap);
+            }
+
+            resources.Save(bundleTempPath);
+        }
+
+        #region DependencyExtension
+        /// <summary>
+        /// Imports authored dependency providers for each package in the manifest,
+        /// and generates dependency providers for certain package types that do not
+        /// have a provider defined.
+        /// </summary>
+        /// <param name="bundle">The <see cref="Output"/> object for the bundle.</param>
+        /// <param name="facades">An indexed collection of chained packages.</param>
+        private void ProcessDependencyProviders(Output bundle, IDictionary<string, PackageFacade> facades)
+        {
+            // First import any authored dependencies. These may merge with imported provides from MSI packages.
+            Table wixDependencyProviderTable = bundle.Tables["WixDependencyProvider"];
+            if (null != wixDependencyProviderTable && 0 < wixDependencyProviderTable.Rows.Count)
+            {
+                // Add package information for each dependency provider authored into the manifest.
+                foreach (Row wixDependencyProviderRow in wixDependencyProviderTable.Rows)
+                {
+                    string packageId = (string)wixDependencyProviderRow[1];
+
+                    PackageFacade facade = null;
+                    if (facades.TryGetValue(packageId, out facade))
+                    {
+                        ProvidesDependency dependency = new ProvidesDependency(wixDependencyProviderRow);
+
+                        if (String.IsNullOrEmpty(dependency.Key))
+                        {
+                            switch (facade.Package.Type)
+                            {
+                                // The WixDependencyExtension allows an empty Key for MSIs and MSPs.
+                                case WixBundlePackageType.Msi:
+                                    dependency.Key = facade.MsiPackage.ProductCode;
+                                    break;
+                                case WixBundlePackageType.Msp:
+                                    dependency.Key = facade.MspPackage.PatchCode;
+                                    break;
+                            }
+                        }
+
+                        if (String.IsNullOrEmpty(dependency.Version))
+                        {
+                            dependency.Version = facade.Package.Version;
+                        }
+
+                        // If the version is still missing, a version could not be harvested from the package and was not authored.
+                        if (String.IsNullOrEmpty(dependency.Version))
+                        {
+                            Messaging.Instance.OnMessage(WixErrors.MissingDependencyVersion(facade.Package.WixChainItemId));
+                        }
+
+                        if (String.IsNullOrEmpty(dependency.DisplayName))
+                        {
+                            dependency.DisplayName = facade.Package.DisplayName;
+                        }
+
+                        if (!facade.Provides.Merge(dependency))
+                        {
+                            Messaging.Instance.OnMessage(WixErrors.DuplicateProviderDependencyKey(dependency.Key, facade.Package.WixChainItemId));
+                        }
+                    }
+                }
+            }
+
+            // Generate providers for MSI packages that still do not have providers.
+            foreach (PackageFacade facade in facades.Values)
+            {
+                string key = null;
+
+                if (WixBundlePackageType.Msi == facade.Package.Type && 0 == facade.Provides.Count)
+                {
+                    key = facade.MsiPackage.ProductCode;
+                }
+                else if (WixBundlePackageType.Msp == facade.Package.Type && 0 == facade.Provides.Count)
+                {
+                    key = facade.MspPackage.PatchCode;
+                }
+
+                if (!String.IsNullOrEmpty(key))
+                {
+                    ProvidesDependency dependency = new ProvidesDependency(key, facade.Package.Version, facade.Package.DisplayName, 0);
+
+                    if (!facade.Provides.Merge(dependency))
+                    {
+                        Messaging.Instance.OnMessage(WixErrors.DuplicateProviderDependencyKey(dependency.Key, facade.Package.WixChainItemId));
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Sets the provider key for the bundle.
+        /// </summary>
+        /// <param name="bundle">The <see cref="Output"/> object for the bundle.</param>
+        /// <param name="bundleInfo">The <see cref="BundleInfo"/> containing the provider key and other information for the bundle.</param>
+        private void SetBundleProviderKey(Output bundle, WixBundleRow bundleInfo)
+        {
+            // From DependencyCommon.cs in the WixDependencyExtension.
+            const int ProvidesAttributesBundle = 0x10000;
+
+            Table wixDependencyProviderTable = bundle.Tables["WixDependencyProvider"];
+            if (null != wixDependencyProviderTable && 0 < wixDependencyProviderTable.Rows.Count)
+            {
+                // Search the WixDependencyProvider table for the single bundle provider key.
+                foreach (Row wixDependencyProviderRow in wixDependencyProviderTable.Rows)
+                {
+                    object attributes = wixDependencyProviderRow[5];
+                    if (null != attributes && 0 != (ProvidesAttributesBundle & (int)attributes))
+                    {
+                        bundleInfo.ProviderKey = (string)wixDependencyProviderRow[2];
+                        break;
+                    }
+                }
+            }
+
+            // Defaults to the bundle ID as the provider key.
+        }
+        #endregion
+    }
+}
diff --git a/src/WixToolset.Core/Bind/BindDatabaseCommand.cs b/src/WixToolset.Core/Bind/BindDatabaseCommand.cs
new file mode 100644
index 00000000..93af2e9a
--- /dev/null
+++ b/src/WixToolset.Core/Bind/BindDatabaseCommand.cs
@@ -0,0 +1,1311 @@
+// 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.Bind
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Globalization;
+    using System.IO;
+    using System.Linq;
+    using WixToolset.Bind.Databases;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+    using WixToolset.Extensibility;
+    using WixToolset.Msi;
+
+    /// <summary>
+    /// Binds a databse.
+    /// </summary>
+    internal class BindDatabaseCommand : ICommand
+    {
+        // As outlined in RFC 4122, this is our namespace for generating name-based (version 3) UUIDs.
+        private static readonly Guid WixComponentGuidNamespace = new Guid("{3064E5C6-FB63-4FE9-AC49-E446A792EFA5}");
+
+        public int Codepage { private get; set; }
+
+        public int CabbingThreadCount { private get; set; }
+
+        public CompressionLevel DefaultCompressionLevel { private get; set; }
+
+        public bool DeltaBinaryPatch { get; set; }
+
+        public IEnumerable<IBinderExtension> Extensions { private get; set; }
+
+        public BinderFileManagerCore FileManagerCore { private get; set; }
+
+        public IEnumerable<IBinderFileManager> FileManagers { private get; set; }
+
+        public IEnumerable<InspectorExtension> InspectorExtensions { private get; set; }
+
+        public Localizer Localizer { private get; set; }
+
+        public string PdbFile { private get; set; }
+
+        public Output Output { private get; set; }
+
+        public string OutputPath { private get; set; }
+
+        public bool SuppressAddingValidationRows { private get; set; }
+
+        public bool SuppressLayout { private get; set; }
+
+        public TableDefinitionCollection TableDefinitions { private get; set; }
+
+        public string TempFilesLocation { private get; set; }
+
+        public Validator Validator { private get; set; }
+
+        public WixVariableResolver WixVariableResolver { private get; set; }
+
+        public IEnumerable<FileTransfer> FileTransfers { get; private set; }
+
+        public IEnumerable<string> ContentFilePaths { get; private set; }
+
+        public void Execute()
+        {
+            List<FileTransfer> fileTransfers = new List<FileTransfer>();
+
+            HashSet<string> suppressedTableNames = new HashSet<string>();
+
+            // Localize fields, resolve wix variables, and resolve file paths.
+            ExtractEmbeddedFiles filesWithEmbeddedFiles = new ExtractEmbeddedFiles();
+
+            IEnumerable<DelayedField> delayedFields;
+            {
+                ResolveFieldsCommand command = new ResolveFieldsCommand();
+                command.Tables = this.Output.Tables;
+                command.FilesWithEmbeddedFiles = filesWithEmbeddedFiles;
+                command.FileManagerCore = this.FileManagerCore;
+                command.FileManagers = this.FileManagers;
+                command.SupportDelayedResolution = true;
+                command.TempFilesLocation = this.TempFilesLocation;
+                command.WixVariableResolver = this.WixVariableResolver;
+                command.Execute();
+
+                delayedFields = command.DelayedFields;
+            }
+
+            if (OutputType.Patch == this.Output.Type)
+            {
+                foreach (SubStorage transform in this.Output.SubStorages)
+                {
+                    ResolveFieldsCommand command = new ResolveFieldsCommand();
+                    command.Tables = transform.Data.Tables;
+                    command.FilesWithEmbeddedFiles = filesWithEmbeddedFiles;
+                    command.FileManagerCore = this.FileManagerCore;
+                    command.FileManagers = this.FileManagers;
+                    command.SupportDelayedResolution = false;
+                    command.TempFilesLocation = this.TempFilesLocation;
+                    command.WixVariableResolver = this.WixVariableResolver;
+                    command.Execute();
+                }
+            }
+
+            // If there are any fields to resolve later, create the cache to populate during bind.
+            IDictionary<string, string> variableCache = null;
+            if (delayedFields.Any())
+            {
+                variableCache = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase);
+            }
+
+            this.LocalizeUI(this.Output.Tables);
+
+            // Process the summary information table before the other tables.
+            bool compressed;
+            bool longNames;
+            int installerVersion;
+            string modularizationGuid;
+            {
+                BindSummaryInfoCommand command = new BindSummaryInfoCommand();
+                command.Output = this.Output;
+                command.Execute();
+
+                compressed = command.Compressed;
+                longNames = command.LongNames;
+                installerVersion = command.InstallerVersion;
+                modularizationGuid = command.ModularizationGuid;
+            }
+
+            // Stop processing if an error previously occurred.
+            if (Messaging.Instance.EncounteredError)
+            {
+                return;
+            }
+
+            // Modularize identifiers and add tables with real streams to the import tables.
+            if (OutputType.Module == this.Output.Type)
+            {
+                // Gather all the suppress modularization identifiers
+                HashSet<string> suppressModularizationIdentifiers = null;
+                Table wixSuppressModularizationTable = this.Output.Tables["WixSuppressModularization"];
+                if (null != wixSuppressModularizationTable)
+                {
+                    suppressModularizationIdentifiers = new HashSet<string>(wixSuppressModularizationTable.Rows.Select(row => (string)row[0]));
+                }
+
+                foreach (Table table in this.Output.Tables)
+                {
+                    table.Modularize(modularizationGuid, suppressModularizationIdentifiers);
+                }
+            }
+
+            // This must occur after all variables and source paths have been resolved and after modularization.
+            List<FileFacade> fileFacades;
+            {
+                GetFileFacadesCommand command = new GetFileFacadesCommand();
+                command.FileTable = this.Output.Tables["File"];
+                command.WixFileTable = this.Output.Tables["WixFile"];
+                command.WixDeltaPatchFileTable = this.Output.Tables["WixDeltaPatchFile"];
+                command.WixDeltaPatchSymbolPathsTable = this.Output.Tables["WixDeltaPatchSymbolPaths"];
+                command.Execute();
+
+                fileFacades = command.FileFacades;
+            }
+
+            ////if (OutputType.Patch == this.Output.Type)
+            ////{
+            ////    foreach (SubStorage substorage in this.Output.SubStorages)
+            ////    {
+            ////        Output transform = substorage.Data;
+
+            ////        ResolveFieldsCommand command = new ResolveFieldsCommand();
+            ////        command.Tables = transform.Tables;
+            ////        command.FilesWithEmbeddedFiles = filesWithEmbeddedFiles;
+            ////        command.FileManagerCore = this.FileManagerCore;
+            ////        command.FileManagers = this.FileManagers;
+            ////        command.SupportDelayedResolution = false;
+            ////        command.TempFilesLocation = this.TempFilesLocation;
+            ////        command.WixVariableResolver = this.WixVariableResolver;
+            ////        command.Execute();
+
+            ////        this.MergeUnrealTables(transform.Tables);
+            ////    }
+            ////}
+
+            {
+                CreateSpecialPropertiesCommand command = new CreateSpecialPropertiesCommand();
+                command.PropertyTable = this.Output.Tables["Property"];
+                command.WixPropertyTable = this.Output.Tables["WixProperty"];
+                command.Execute();
+            }
+
+            if (Messaging.Instance.EncounteredError)
+            {
+                return;
+            }
+
+            // Add binder variables for all properties.
+            Table propertyTable = this.Output.Tables["Property"];
+            if (null != propertyTable)
+            {
+                foreach (PropertyRow propertyRow in propertyTable.Rows)
+                {
+                    // Set the ProductCode if it is to be generated.
+                    if (OutputType.Product == this.Output.Type && "ProductCode".Equals(propertyRow.Property, StringComparison.Ordinal) && "*".Equals(propertyRow.Value, StringComparison.Ordinal))
+                    {
+                        propertyRow.Value = Common.GenerateGuid();
+
+                        // Update the target ProductCode in any instance transforms.
+                        foreach (SubStorage subStorage in this.Output.SubStorages)
+                        {
+                            Output subStorageOutput = subStorage.Data;
+                            if (OutputType.Transform != subStorageOutput.Type)
+                            {
+                                continue;
+                            }
+
+                            Table instanceSummaryInformationTable = subStorageOutput.Tables["_SummaryInformation"];
+                            foreach (Row row in instanceSummaryInformationTable.Rows)
+                            {
+                                if ((int)SummaryInformation.Transform.ProductCodes == row.FieldAsInteger(0))
+                                {
+                                    row[1] = row.FieldAsString(1).Replace("*", propertyRow.Value);
+                                    break;
+                                }
+                            }
+                        }
+                    }
+
+                    // Add the property name and value to the variableCache.
+                    if (null != variableCache)
+                    {
+                        string key = String.Concat("property.", Demodularize(this.Output.Type, modularizationGuid, propertyRow.Property));
+                        variableCache[key] = propertyRow.Value;
+                    }
+                }
+            }
+
+            // Extract files that come from cabinet files (this does not extract files from merge modules).
+            {
+                ExtractEmbeddedFilesCommand command = new ExtractEmbeddedFilesCommand();
+                command.FilesWithEmbeddedFiles = filesWithEmbeddedFiles;
+                command.Execute();
+            }
+
+            if (OutputType.Product == this.Output.Type)
+            {
+                // Retrieve files and their information from merge modules.
+                Table wixMergeTable = this.Output.Tables["WixMerge"];
+
+                if (null != wixMergeTable)
+                {
+                    ExtractMergeModuleFilesCommand command = new ExtractMergeModuleFilesCommand();
+                    command.FileFacades = fileFacades;
+                    command.FileTable = this.Output.Tables["File"];
+                    command.WixFileTable = this.Output.Tables["WixFile"];
+                    command.WixMergeTable = wixMergeTable;
+                    command.OutputInstallerVersion = installerVersion;
+                    command.SuppressLayout = this.SuppressLayout;
+                    command.TempFilesLocation = this.TempFilesLocation;
+                    command.Execute();
+
+                    fileFacades.AddRange(command.MergeModulesFileFacades);
+                }
+            }
+            else if (OutputType.Patch == this.Output.Type)
+            {
+                // Merge transform data into the output object.
+                IEnumerable<FileFacade> filesFromTransform = this.CopyFromTransformData(this.Output);
+
+                fileFacades.AddRange(filesFromTransform);
+            }
+
+            // stop processing if an error previously occurred
+            if (Messaging.Instance.EncounteredError)
+            {
+                return;
+            }
+
+            Messaging.Instance.OnMessage(WixVerboses.UpdatingFileInformation());
+
+            // Gather information about files that did not come from merge modules (i.e. rows with a reference to the File table).
+            {
+                UpdateFileFacadesCommand command = new UpdateFileFacadesCommand();
+                command.FileFacades = fileFacades;
+                command.UpdateFileFacades = fileFacades.Where(f => !f.FromModule);
+                command.ModularizationGuid = modularizationGuid;
+                command.Output = this.Output;
+                command.OverwriteHash = true;
+                command.TableDefinitions = this.TableDefinitions;
+                command.VariableCache = variableCache;
+                command.Execute();
+            }
+
+            // Set generated component guids.
+            this.SetComponentGuids(this.Output);
+
+            // With the Component Guids set now we can create instance transforms.
+            this.CreateInstanceTransforms(this.Output);
+
+            this.ValidateComponentGuids(this.Output);
+
+            this.UpdateControlText(this.Output);
+
+            if (delayedFields.Any())
+            {
+                ResolveDelayedFieldsCommand command = new ResolveDelayedFieldsCommand();
+                command.OutputType = this.Output.Type;
+                command.DelayedFields = delayedFields;
+                command.ModularizationGuid = null;
+                command.VariableCache = variableCache;
+                command.Execute();
+            }
+
+            // Assign files to media.
+            RowDictionary<MediaRow> assignedMediaRows;
+            Dictionary<MediaRow, IEnumerable<FileFacade>> filesByCabinetMedia;
+            IEnumerable<FileFacade> uncompressedFiles;
+            {
+                AssignMediaCommand command = new AssignMediaCommand();
+                command.FilesCompressed = compressed;
+                command.FileFacades = fileFacades;
+                command.Output = this.Output;
+                command.TableDefinitions = this.TableDefinitions;
+                command.Execute();
+
+                assignedMediaRows = command.MediaRows;
+                filesByCabinetMedia = command.FileFacadesByCabinetMedia;
+                uncompressedFiles = command.UncompressedFileFacades;
+            }
+
+            // Update file sequence.
+            this.UpdateMediaSequences(this.Output.Type, fileFacades, assignedMediaRows);
+
+            // stop processing if an error previously occurred
+            if (Messaging.Instance.EncounteredError)
+            {
+                return;
+            }
+
+            // Extended binder extensions can be called now that fields are resolved.
+            {
+                Table updatedFiles = this.Output.EnsureTable(this.TableDefinitions["WixBindUpdatedFiles"]);
+
+                foreach (BinderExtension extension in this.Extensions)
+                {
+                    extension.AfterResolvedFields(this.Output);
+                }
+
+                List<FileFacade> updatedFileFacades = new List<FileFacade>();
+
+                foreach (Row updatedFile in updatedFiles.Rows)
+                {
+                    string updatedId = updatedFile.FieldAsString(0);
+
+                    FileFacade updatedFacade = fileFacades.First(f => f.File.File.Equals(updatedId));
+
+                    updatedFileFacades.Add(updatedFacade);
+                }
+
+                if (updatedFileFacades.Any())
+                {
+                    UpdateFileFacadesCommand command = new UpdateFileFacadesCommand();
+                    command.FileFacades = fileFacades;
+                    command.UpdateFileFacades = updatedFileFacades;
+                    command.ModularizationGuid = modularizationGuid;
+                    command.Output = this.Output;
+                    command.OverwriteHash = true;
+                    command.TableDefinitions = this.TableDefinitions;
+                    command.VariableCache = variableCache;
+                    command.Execute();
+                }
+            }
+
+            // stop processing if an error previously occurred
+            if (Messaging.Instance.EncounteredError)
+            {
+                return;
+            }
+
+            Directory.CreateDirectory(this.TempFilesLocation);
+
+            if (OutputType.Patch == this.Output.Type && this.DeltaBinaryPatch)
+            {
+                CreateDeltaPatchesCommand command = new CreateDeltaPatchesCommand();
+                command.FileFacades = fileFacades;
+                command.WixPatchIdTable = this.Output.Tables["WixPatchId"];
+                command.TempFilesLocation = this.TempFilesLocation;
+                command.Execute();
+            }
+
+            // create cabinet files and process uncompressed files
+            string layoutDirectory = Path.GetDirectoryName(this.OutputPath);
+            if (!this.SuppressLayout || OutputType.Module == this.Output.Type)
+            {
+                Messaging.Instance.OnMessage(WixVerboses.CreatingCabinetFiles());
+
+                CreateCabinetsCommand command = new CreateCabinetsCommand();
+                command.CabbingThreadCount = this.CabbingThreadCount;
+                command.DefaultCompressionLevel = this.DefaultCompressionLevel;
+                command.Output = this.Output;
+                command.FileManagers = this.FileManagers;
+                command.LayoutDirectory = layoutDirectory;
+                command.Compressed = compressed;
+                command.FileRowsByCabinet = filesByCabinetMedia;
+                command.ResolveMedia = this.ResolveMedia;
+                command.TableDefinitions = this.TableDefinitions;
+                command.TempFilesLocation = this.TempFilesLocation;
+                command.WixMediaTable = this.Output.Tables["WixMedia"];
+                command.Execute();
+
+                fileTransfers.AddRange(command.FileTransfers);
+            }
+
+            if (OutputType.Patch == this.Output.Type)
+            {
+                // copy output data back into the transforms
+                this.CopyToTransformData(this.Output);
+            }
+
+            // stop processing if an error previously occurred
+            if (Messaging.Instance.EncounteredError)
+            {
+                return;
+            }
+
+            // add back suppressed tables which must be present prior to merging in modules
+            if (OutputType.Product == this.Output.Type)
+            {
+                Table wixMergeTable = this.Output.Tables["WixMerge"];
+
+                if (null != wixMergeTable && 0 < wixMergeTable.Rows.Count)
+                {
+                    foreach (SequenceTable sequence in Enum.GetValues(typeof(SequenceTable)))
+                    {
+                        string sequenceTableName = sequence.ToString();
+                        Table sequenceTable = this.Output.Tables[sequenceTableName];
+
+                        if (null == sequenceTable)
+                        {
+                            sequenceTable = this.Output.EnsureTable(this.TableDefinitions[sequenceTableName]);
+                        }
+
+                        if (0 == sequenceTable.Rows.Count)
+                        {
+                            suppressedTableNames.Add(sequenceTableName);
+                        }
+                    }
+                }
+            }
+
+            foreach (BinderExtension extension in this.Extensions)
+            {
+                extension.Finish(this.Output);
+            }
+
+            // generate database file
+            Messaging.Instance.OnMessage(WixVerboses.GeneratingDatabase());
+            string tempDatabaseFile = Path.Combine(this.TempFilesLocation, Path.GetFileName(this.OutputPath));
+            this.GenerateDatabase(this.Output, tempDatabaseFile, false, false);
+
+            FileTransfer transfer;
+            if (FileTransfer.TryCreate(tempDatabaseFile, this.OutputPath, true, this.Output.Type.ToString(), null, out transfer)) // note where this database needs to move in the future
+            {
+                transfer.Built = true;
+                fileTransfers.Add(transfer);
+            }
+
+            // stop processing if an error previously occurred
+            if (Messaging.Instance.EncounteredError)
+            {
+                return;
+            }
+
+            // Output the output to a file
+            Pdb pdb = new Pdb();
+            pdb.Output = this.Output;
+            if (!String.IsNullOrEmpty(this.PdbFile))
+            {
+                pdb.Save(this.PdbFile);
+            }
+
+            // Merge modules.
+            if (OutputType.Product == this.Output.Type)
+            {
+                Messaging.Instance.OnMessage(WixVerboses.MergingModules());
+
+                MergeModulesCommand command = new MergeModulesCommand();
+                command.FileFacades = fileFacades;
+                command.Output = this.Output;
+                command.OutputPath = tempDatabaseFile;
+                command.SuppressedTableNames = suppressedTableNames;
+                command.Execute();
+
+                // stop processing if an error previously occurred
+                if (Messaging.Instance.EncounteredError)
+                {
+                    return;
+                }
+            }
+
+            // inspect the MSI prior to running ICEs
+            InspectorCore inspectorCore = new InspectorCore();
+            foreach (InspectorExtension inspectorExtension in this.InspectorExtensions)
+            {
+                inspectorExtension.Core = inspectorCore;
+                inspectorExtension.InspectDatabase(tempDatabaseFile, pdb);
+
+                inspectorExtension.Core = null; // reset.
+            }
+
+            if (Messaging.Instance.EncounteredError)
+            {
+                return;
+            }
+
+            // validate the output if there is an MSI validator
+            if (null != this.Validator)
+            {
+                Stopwatch stopwatch = Stopwatch.StartNew();
+
+                // set the output file for source line information
+                this.Validator.Output = this.Output;
+
+                Messaging.Instance.OnMessage(WixVerboses.ValidatingDatabase());
+
+                this.Validator.Validate(tempDatabaseFile);
+
+                stopwatch.Stop();
+                Messaging.Instance.OnMessage(WixVerboses.ValidatedDatabase(stopwatch.ElapsedMilliseconds));
+
+                // Stop processing if an error occurred.
+                if (Messaging.Instance.EncounteredError)
+                {
+                    return;
+                }
+            }
+
+            // Process uncompressed files.
+            if (!Messaging.Instance.EncounteredError && !this.SuppressLayout && uncompressedFiles.Any())
+            {
+                ProcessUncompressedFilesCommand command = new ProcessUncompressedFilesCommand();
+                command.Compressed = compressed;
+                command.FileFacades = uncompressedFiles;
+                command.LayoutDirectory = layoutDirectory;
+                command.LongNamesInImage = longNames;
+                command.MediaRows = assignedMediaRows;
+                command.ResolveMedia = this.ResolveMedia;
+                command.DatabasePath = tempDatabaseFile;
+                command.WixMediaTable = this.Output.Tables["WixMedia"];
+                command.Execute();
+
+                fileTransfers.AddRange(command.FileTransfers);
+            }
+
+            this.FileTransfers = fileTransfers;
+            this.ContentFilePaths = fileFacades.Select(r => r.WixFile.Source).ToList();
+        }
+
+        /// <summary>
+        /// Localize dialogs and controls.
+        /// </summary>
+        /// <param name="tables">The tables to localize.</param>
+        private void LocalizeUI(TableIndexedCollection tables)
+        {
+            Table dialogTable = tables["Dialog"];
+            if (null != dialogTable)
+            {
+                foreach (Row row in dialogTable.Rows)
+                {
+                    string dialog = (string)row[0];
+                    LocalizedControl localizedControl = this.Localizer.GetLocalizedControl(dialog, null);
+                    if (null != localizedControl)
+                    {
+                        if (CompilerConstants.IntegerNotSet != localizedControl.X)
+                        {
+                            row[1] = localizedControl.X;
+                        }
+
+                        if (CompilerConstants.IntegerNotSet != localizedControl.Y)
+                        {
+                            row[2] = localizedControl.Y;
+                        }
+
+                        if (CompilerConstants.IntegerNotSet != localizedControl.Width)
+                        {
+                            row[3] = localizedControl.Width;
+                        }
+
+                        if (CompilerConstants.IntegerNotSet != localizedControl.Height)
+                        {
+                            row[4] = localizedControl.Height;
+                        }
+
+                        row[5] = (int)row[5] | localizedControl.Attributes;
+
+                        if (!String.IsNullOrEmpty(localizedControl.Text))
+                        {
+                            row[6] = localizedControl.Text;
+                        }
+                    }
+                }
+            }
+
+            Table controlTable = tables["Control"];
+            if (null != controlTable)
+            {
+                foreach (Row row in controlTable.Rows)
+                {
+                    string dialog = (string)row[0];
+                    string control = (string)row[1];
+                    LocalizedControl localizedControl = this.Localizer.GetLocalizedControl(dialog, control);
+                    if (null != localizedControl)
+                    {
+                        if (CompilerConstants.IntegerNotSet != localizedControl.X)
+                        {
+                            row[3] = localizedControl.X.ToString();
+                        }
+
+                        if (CompilerConstants.IntegerNotSet != localizedControl.Y)
+                        {
+                            row[4] = localizedControl.Y.ToString();
+                        }
+
+                        if (CompilerConstants.IntegerNotSet != localizedControl.Width)
+                        {
+                            row[5] = localizedControl.Width.ToString();
+                        }
+
+                        if (CompilerConstants.IntegerNotSet != localizedControl.Height)
+                        {
+                            row[6] = localizedControl.Height.ToString();
+                        }
+
+                        row[7] = (int)row[7] | localizedControl.Attributes;
+
+                        if (!String.IsNullOrEmpty(localizedControl.Text))
+                        {
+                            row[9] = localizedControl.Text;
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Copy file data between transform substorages and the patch output object
+        /// </summary>
+        /// <param name="output">The output to bind.</param>
+        /// <param name="allFileRows">True if copying from transform to patch, false the other way.</param>
+        private IEnumerable<FileFacade> CopyFromTransformData(Output output)
+        {
+            CopyTransformDataCommand command = new CopyTransformDataCommand();
+            command.CopyOutFileRows = true;
+            command.FileManagerCore = this.FileManagerCore;
+            command.FileManagers = this.FileManagers;
+            command.Output = output;
+            command.TableDefinitions = this.TableDefinitions;
+            command.Execute();
+
+            return command.FileFacades;
+        }
+
+        /// <summary>
+        /// Copy file data between transform substorages and the patch output object
+        /// </summary>
+        /// <param name="output">The output to bind.</param>
+        /// <param name="allFileRows">True if copying from transform to patch, false the other way.</param>
+        private void CopyToTransformData(Output output)
+        {
+            CopyTransformDataCommand command = new CopyTransformDataCommand();
+            command.CopyOutFileRows = false;
+            command.FileManagerCore = this.FileManagerCore;
+            command.FileManagers = this.FileManagers;
+            command.Output = output;
+            command.TableDefinitions = this.TableDefinitions;
+            command.Execute();
+        }
+
+        /// <summary>
+        /// Takes an id, and demodularizes it (if possible).
+        /// </summary>
+        /// <remarks>
+        /// If the output type is a module, returns a demodularized version of an id. Otherwise, returns the id.
+        /// </remarks>
+        /// <param name="outputType">The type of the output to bind.</param>
+        /// <param name="modularizationGuid">The modularization GUID.</param>
+        /// <param name="id">The id to demodularize.</param>
+        /// <returns>The demodularized id.</returns>
+        internal static string Demodularize(OutputType outputType, string modularizationGuid, string id)
+        {
+            if (OutputType.Module == outputType && id.EndsWith(String.Concat(".", modularizationGuid), StringComparison.Ordinal))
+            {
+                id = id.Substring(0, id.Length - 37);
+            }
+
+            return id;
+        }
+
+        private void UpdateMediaSequences(OutputType outputType, IEnumerable<FileFacade> fileFacades, RowDictionary<MediaRow> mediaRows)
+        {
+            // Calculate sequence numbers and media disk id layout for all file media information objects.
+            if (OutputType.Module == outputType)
+            {
+                int lastSequence = 0;
+                foreach (FileFacade facade in fileFacades) // TODO: Sort these rows directory path and component id and maybe file size or file extension and other creative ideas to get optimal install speed out of MSI.
+                {
+                    facade.File.Sequence = ++lastSequence;
+                }
+            }
+            else
+            {
+                int lastSequence = 0;
+                MediaRow mediaRow = null;
+                Dictionary<int, List<FileFacade>> patchGroups = new Dictionary<int, List<FileFacade>>();
+
+                // sequence the non-patch-added files
+                foreach (FileFacade facade in fileFacades) // TODO: Sort these rows directory path and component id and maybe file size or file extension and other creative ideas to get optimal install speed out of MSI.
+                {
+                    if (null == mediaRow)
+                    {
+                        mediaRow = mediaRows.Get(facade.WixFile.DiskId);
+                        if (OutputType.Patch == outputType)
+                        {
+                            // patch Media cannot start at zero
+                            lastSequence = mediaRow.LastSequence;
+                        }
+                    }
+                    else if (mediaRow.DiskId != facade.WixFile.DiskId)
+                    {
+                        mediaRow.LastSequence = lastSequence;
+                        mediaRow = mediaRows.Get(facade.WixFile.DiskId);
+                    }
+
+                    if (0 < facade.WixFile.PatchGroup)
+                    {
+                        List<FileFacade> patchGroup = patchGroups[facade.WixFile.PatchGroup];
+
+                        if (null == patchGroup)
+                        {
+                            patchGroup = new List<FileFacade>();
+                            patchGroups.Add(facade.WixFile.PatchGroup, patchGroup);
+                        }
+
+                        patchGroup.Add(facade);
+                    }
+                    else
+                    {
+                        facade.File.Sequence = ++lastSequence;
+                    }
+                }
+
+                if (null != mediaRow)
+                {
+                    mediaRow.LastSequence = lastSequence;
+                    mediaRow = null;
+                }
+
+                // sequence the patch-added files
+                foreach (List<FileFacade> patchGroup in patchGroups.Values)
+                {
+                    foreach (FileFacade facade in patchGroup)
+                    {
+                        if (null == mediaRow)
+                        {
+                            mediaRow = mediaRows.Get(facade.WixFile.DiskId);
+                        }
+                        else if (mediaRow.DiskId != facade.WixFile.DiskId)
+                        {
+                            mediaRow.LastSequence = lastSequence;
+                            mediaRow = mediaRows.Get(facade.WixFile.DiskId);
+                        }
+
+                        facade.File.Sequence = ++lastSequence;
+                    }
+                }
+
+                if (null != mediaRow)
+                {
+                    mediaRow.LastSequence = lastSequence;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Set the guids for components with generatable guids.
+        /// </summary>
+        /// <param name="output">Internal representation of the database to operate on.</param>
+        private void SetComponentGuids(Output output)
+        {
+            Table componentTable = output.Tables["Component"];
+            if (null != componentTable)
+            {
+                Hashtable registryKeyRows = null;
+                Hashtable directories = null;
+                Hashtable componentIdGenSeeds = null;
+                Dictionary<string, List<FileRow>> fileRows = null;
+
+                // find components with generatable guids
+                foreach (ComponentRow componentRow in componentTable.Rows)
+                {
+                    // component guid will be generated
+                    if ("*" == componentRow.Guid)
+                    {
+                        if (null == componentRow.KeyPath || componentRow.IsOdbcDataSourceKeyPath)
+                        {
+                            Messaging.Instance.OnMessage(WixErrors.IllegalComponentWithAutoGeneratedGuid(componentRow.SourceLineNumbers));
+                        }
+                        else if (componentRow.IsRegistryKeyPath)
+                        {
+                            if (null == registryKeyRows)
+                            {
+                                Table registryTable = output.Tables["Registry"];
+
+                                registryKeyRows = new Hashtable(registryTable.Rows.Count);
+
+                                foreach (Row registryRow in registryTable.Rows)
+                                {
+                                    registryKeyRows.Add((string)registryRow[0], registryRow);
+                                }
+                            }
+
+                            Row foundRow = registryKeyRows[componentRow.KeyPath] as Row;
+
+                            string bitness = componentRow.Is64Bit ? "64" : String.Empty;
+                            if (null != foundRow)
+                            {
+                                string regkey = String.Concat(bitness, foundRow[1], "\\", foundRow[2], "\\", foundRow[3]);
+                                componentRow.Guid = Uuid.NewUuid(BindDatabaseCommand.WixComponentGuidNamespace, regkey.ToLowerInvariant()).ToString("B").ToUpperInvariant();
+                            }
+                        }
+                        else // must be a File KeyPath
+                        {
+                            // if the directory table hasn't been loaded into an indexed hash
+                            // of directory ids to target names do that now.
+                            if (null == directories)
+                            {
+                                Table directoryTable = output.Tables["Directory"];
+
+                                int numDirectoryTableRows = (null != directoryTable) ? directoryTable.Rows.Count : 0;
+
+                                directories = new Hashtable(numDirectoryTableRows);
+
+                                // get the target paths for all directories
+                                if (null != directoryTable)
+                                {
+                                    foreach (Row row in directoryTable.Rows)
+                                    {
+                                        // if the directory Id already exists, we will skip it here since
+                                        // checking for duplicate primary keys is done later when importing tables
+                                        // into database
+                                        if (directories.ContainsKey(row[0]))
+                                        {
+                                            continue;
+                                        }
+
+                                        string targetName = Installer.GetName((string)row[2], false, true);
+                                        directories.Add(row[0], new ResolvedDirectory((string)row[1], targetName));
+                                    }
+                                }
+                            }
+
+                            // if the component id generation seeds have not been indexed
+                            // from the WixDirectory table do that now.
+                            if (null == componentIdGenSeeds)
+                            {
+                                Table wixDirectoryTable = output.Tables["WixDirectory"];
+
+                                int numWixDirectoryRows = (null != wixDirectoryTable) ? wixDirectoryTable.Rows.Count : 0;
+
+                                componentIdGenSeeds = new Hashtable(numWixDirectoryRows);
+
+                                // if there are any WixDirectory rows, build up the Component Guid
+                                // generation seeds indexed by Directory/@Id.
+                                if (null != wixDirectoryTable)
+                                {
+                                    foreach (Row row in wixDirectoryTable.Rows)
+                                    {
+                                        componentIdGenSeeds.Add(row[0], (string)row[1]);
+                                    }
+                                }
+                            }
+
+                            // if the file rows have not been indexed by File.Component yet
+                            // then do that now
+                            if (null == fileRows)
+                            {
+                                Table fileTable = output.Tables["File"];
+
+                                int numFileRows = (null != fileTable) ? fileTable.Rows.Count : 0;
+
+                                fileRows = new Dictionary<string, List<FileRow>>(numFileRows);
+
+                                if (null != fileTable)
+                                {
+                                    foreach (FileRow file in fileTable.Rows)
+                                    {
+                                        List<FileRow> files;
+                                        if (!fileRows.TryGetValue(file.Component, out files))
+                                        {
+                                            files = new List<FileRow>();
+                                            fileRows.Add(file.Component, files);
+                                        }
+
+                                        files.Add(file);
+                                    }
+                                }
+                            }
+
+                            // validate component meets all the conditions to have a generated guid
+                            List<FileRow> currentComponentFiles = fileRows[componentRow.Component];
+                            int numFilesInComponent = currentComponentFiles.Count;
+                            string path = null;
+
+                            foreach (FileRow fileRow in currentComponentFiles)
+                            {
+                                if (fileRow.File == componentRow.KeyPath)
+                                {
+                                    // calculate the key file's canonical target path
+                                    string directoryPath = Binder.GetDirectoryPath(directories, componentIdGenSeeds, componentRow.Directory, true);
+                                    string fileName = Installer.GetName(fileRow.FileName, false, true).ToLower(CultureInfo.InvariantCulture);
+                                    path = Path.Combine(directoryPath, fileName);
+
+                                    // find paths that are not canonicalized
+                                    if (path.StartsWith(@"PersonalFolder\my pictures", StringComparison.Ordinal) ||
+                                        path.StartsWith(@"ProgramFilesFolder\common files", StringComparison.Ordinal) ||
+                                        path.StartsWith(@"ProgramMenuFolder\startup", StringComparison.Ordinal) ||
+                                        path.StartsWith("TARGETDIR", StringComparison.Ordinal) ||
+                                        path.StartsWith(@"StartMenuFolder\programs", StringComparison.Ordinal) ||
+                                        path.StartsWith(@"WindowsFolder\fonts", StringComparison.Ordinal))
+                                    {
+                                        Messaging.Instance.OnMessage(WixErrors.IllegalPathForGeneratedComponentGuid(componentRow.SourceLineNumbers, fileRow.Component, path));
+                                    }
+
+                                    // if component has more than one file, the key path must be versioned
+                                    if (1 < numFilesInComponent && String.IsNullOrEmpty(fileRow.Version))
+                                    {
+                                        Messaging.Instance.OnMessage(WixErrors.IllegalGeneratedGuidComponentUnversionedKeypath(componentRow.SourceLineNumbers));
+                                    }
+                                }
+                                else
+                                {
+                                    // not a key path, so it must be an unversioned file if component has more than one file
+                                    if (1 < numFilesInComponent && !String.IsNullOrEmpty(fileRow.Version))
+                                    {
+                                        Messaging.Instance.OnMessage(WixErrors.IllegalGeneratedGuidComponentVersionedNonkeypath(componentRow.SourceLineNumbers));
+                                    }
+                                }
+                            }
+
+                            // if the rules were followed, reward with a generated guid
+                            if (!Messaging.Instance.EncounteredError)
+                            {
+                                componentRow.Guid = Uuid.NewUuid(BindDatabaseCommand.WixComponentGuidNamespace, path).ToString("B").ToUpperInvariant();
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Creates instance transform substorages in the output.
+        /// </summary>
+        /// <param name="output">Output containing instance transform definitions.</param>
+        private void CreateInstanceTransforms(Output output)
+        {
+            // Create and add substorages for instance transforms.
+            Table wixInstanceTransformsTable = output.Tables["WixInstanceTransforms"];
+            if (null != wixInstanceTransformsTable && 0 <= wixInstanceTransformsTable.Rows.Count)
+            {
+                string targetProductCode = null;
+                string targetUpgradeCode = null;
+                string targetProductVersion = null;
+
+                Table targetSummaryInformationTable = output.Tables["_SummaryInformation"];
+                Table targetPropertyTable = output.Tables["Property"];
+
+                // Get the data from target database
+                foreach (Row propertyRow in targetPropertyTable.Rows)
+                {
+                    if ("ProductCode" == (string)propertyRow[0])
+                    {
+                        targetProductCode = (string)propertyRow[1];
+                    }
+                    else if ("ProductVersion" == (string)propertyRow[0])
+                    {
+                        targetProductVersion = (string)propertyRow[1];
+                    }
+                    else if ("UpgradeCode" == (string)propertyRow[0])
+                    {
+                        targetUpgradeCode = (string)propertyRow[1];
+                    }
+                }
+
+                // Index the Instance Component Rows.
+                Dictionary<string, ComponentRow> instanceComponentGuids = new Dictionary<string, ComponentRow>();
+                Table targetInstanceComponentTable = output.Tables["WixInstanceComponent"];
+                if (null != targetInstanceComponentTable && 0 < targetInstanceComponentTable.Rows.Count)
+                {
+                    foreach (Row row in targetInstanceComponentTable.Rows)
+                    {
+                        // Build up all the instances, we'll get the Components rows from the real Component table.
+                        instanceComponentGuids.Add((string)row[0], null);
+                    }
+
+                    Table targetComponentTable = output.Tables["Component"];
+                    foreach (ComponentRow componentRow in targetComponentTable.Rows)
+                    {
+                        string component = (string)componentRow[0];
+                        if (instanceComponentGuids.ContainsKey(component))
+                        {
+                            instanceComponentGuids[component] = componentRow;
+                        }
+                    }
+                }
+
+                // Generate the instance transforms
+                foreach (Row instanceRow in wixInstanceTransformsTable.Rows)
+                {
+                    string instanceId = (string)instanceRow[0];
+
+                    Output instanceTransform = new Output(instanceRow.SourceLineNumbers);
+                    instanceTransform.Type = OutputType.Transform;
+                    instanceTransform.Codepage = output.Codepage;
+
+                    Table instanceSummaryInformationTable = instanceTransform.EnsureTable(this.TableDefinitions["_SummaryInformation"]);
+                    string targetPlatformAndLanguage = null;
+
+                    foreach (Row summaryInformationRow in targetSummaryInformationTable.Rows)
+                    {
+                        if (7 == (int)summaryInformationRow[0]) // PID_TEMPLATE
+                        {
+                            targetPlatformAndLanguage = (string)summaryInformationRow[1];
+                        }
+
+                        // Copy the row's data to the transform.
+                        Row copyOfSummaryRow = instanceSummaryInformationTable.CreateRow(null);
+                        copyOfSummaryRow[0] = summaryInformationRow[0];
+                        copyOfSummaryRow[1] = summaryInformationRow[1];
+                    }
+
+                    // Modify the appropriate properties.
+                    Table propertyTable = instanceTransform.EnsureTable(this.TableDefinitions["Property"]);
+
+                    // Change the ProductCode property
+                    string productCode = (string)instanceRow[2];
+                    if ("*" == productCode)
+                    {
+                        productCode = Common.GenerateGuid();
+                    }
+
+                    Row productCodeRow = propertyTable.CreateRow(instanceRow.SourceLineNumbers);
+                    productCodeRow.Operation = RowOperation.Modify;
+                    productCodeRow.Fields[1].Modified = true;
+                    productCodeRow[0] = "ProductCode";
+                    productCodeRow[1] = productCode;
+
+                    // Change the instance property
+                    Row instanceIdRow = propertyTable.CreateRow(instanceRow.SourceLineNumbers);
+                    instanceIdRow.Operation = RowOperation.Modify;
+                    instanceIdRow.Fields[1].Modified = true;
+                    instanceIdRow[0] = (string)instanceRow[1];
+                    instanceIdRow[1] = instanceId;
+
+                    if (null != instanceRow[3])
+                    {
+                        // Change the ProductName property
+                        Row productNameRow = propertyTable.CreateRow(instanceRow.SourceLineNumbers);
+                        productNameRow.Operation = RowOperation.Modify;
+                        productNameRow.Fields[1].Modified = true;
+                        productNameRow[0] = "ProductName";
+                        productNameRow[1] = (string)instanceRow[3];
+                    }
+
+                    if (null != instanceRow[4])
+                    {
+                        // Change the UpgradeCode property
+                        Row upgradeCodeRow = propertyTable.CreateRow(instanceRow.SourceLineNumbers);
+                        upgradeCodeRow.Operation = RowOperation.Modify;
+                        upgradeCodeRow.Fields[1].Modified = true;
+                        upgradeCodeRow[0] = "UpgradeCode";
+                        upgradeCodeRow[1] = instanceRow[4];
+
+                        // Change the Upgrade table
+                        Table targetUpgradeTable = output.Tables["Upgrade"];
+                        if (null != targetUpgradeTable && 0 <= targetUpgradeTable.Rows.Count)
+                        {
+                            string upgradeId = (string)instanceRow[4];
+                            Table upgradeTable = instanceTransform.EnsureTable(this.TableDefinitions["Upgrade"]);
+                            foreach (Row row in targetUpgradeTable.Rows)
+                            {
+                                // In case they are upgrading other codes to this new product, leave the ones that don't match the
+                                // Product.UpgradeCode intact.
+                                if (targetUpgradeCode == (string)row[0])
+                                {
+                                    Row upgradeRow = upgradeTable.CreateRow(null);
+                                    upgradeRow.Operation = RowOperation.Add;
+                                    upgradeRow.Fields[0].Modified = true;
+                                    // I was hoping to be able to RowOperation.Modify, but that didn't appear to function.
+                                    // upgradeRow.Fields[0].PreviousData = (string)row[0];
+
+                                    // Inserting a new Upgrade record with the updated UpgradeCode
+                                    upgradeRow[0] = upgradeId;
+                                    upgradeRow[1] = row[1];
+                                    upgradeRow[2] = row[2];
+                                    upgradeRow[3] = row[3];
+                                    upgradeRow[4] = row[4];
+                                    upgradeRow[5] = row[5];
+                                    upgradeRow[6] = row[6];
+
+                                    // Delete the old row
+                                    Row upgradeRemoveRow = upgradeTable.CreateRow(null);
+                                    upgradeRemoveRow.Operation = RowOperation.Delete;
+                                    upgradeRemoveRow[0] = row[0];
+                                    upgradeRemoveRow[1] = row[1];
+                                    upgradeRemoveRow[2] = row[2];
+                                    upgradeRemoveRow[3] = row[3];
+                                    upgradeRemoveRow[4] = row[4];
+                                    upgradeRemoveRow[5] = row[5];
+                                    upgradeRemoveRow[6] = row[6];
+                                }
+                            }
+                        }
+                    }
+
+                    // If there are instance Components generate new GUIDs for them.
+                    if (0 < instanceComponentGuids.Count)
+                    {
+                        Table componentTable = instanceTransform.EnsureTable(this.TableDefinitions["Component"]);
+                        foreach (ComponentRow targetComponentRow in instanceComponentGuids.Values)
+                        {
+                            string guid = targetComponentRow.Guid;
+                            if (!String.IsNullOrEmpty(guid))
+                            {
+                                Row instanceComponentRow = componentTable.CreateRow(targetComponentRow.SourceLineNumbers);
+                                instanceComponentRow.Operation = RowOperation.Modify;
+                                instanceComponentRow.Fields[1].Modified = true;
+                                instanceComponentRow[0] = targetComponentRow[0];
+                                instanceComponentRow[1] = Uuid.NewUuid(BindDatabaseCommand.WixComponentGuidNamespace, String.Concat(guid, instanceId)).ToString("B").ToUpper(CultureInfo.InvariantCulture);
+                                instanceComponentRow[2] = targetComponentRow[2];
+                                instanceComponentRow[3] = targetComponentRow[3];
+                                instanceComponentRow[4] = targetComponentRow[4];
+                                instanceComponentRow[5] = targetComponentRow[5];
+                            }
+                        }
+                    }
+
+                    // Update the summary information
+                    Hashtable summaryRows = new Hashtable(instanceSummaryInformationTable.Rows.Count);
+                    foreach (Row row in instanceSummaryInformationTable.Rows)
+                    {
+                        summaryRows[row[0]] = row;
+
+                        if ((int)SummaryInformation.Transform.UpdatedPlatformAndLanguage == (int)row[0])
+                        {
+                            row[1] = targetPlatformAndLanguage;
+                        }
+                        else if ((int)SummaryInformation.Transform.ProductCodes == (int)row[0])
+                        {
+                            row[1] = String.Concat(targetProductCode, targetProductVersion, ';', productCode, targetProductVersion, ';', targetUpgradeCode);
+                        }
+                        else if ((int)SummaryInformation.Transform.ValidationFlags == (int)row[0])
+                        {
+                            row[1] = 0;
+                        }
+                        else if ((int)SummaryInformation.Transform.Security == (int)row[0])
+                        {
+                            row[1] = "4";
+                        }
+                    }
+
+                    if (!summaryRows.Contains((int)SummaryInformation.Transform.UpdatedPlatformAndLanguage))
+                    {
+                        Row summaryRow = instanceSummaryInformationTable.CreateRow(null);
+                        summaryRow[0] = (int)SummaryInformation.Transform.UpdatedPlatformAndLanguage;
+                        summaryRow[1] = targetPlatformAndLanguage;
+                    }
+                    else if (!summaryRows.Contains((int)SummaryInformation.Transform.ValidationFlags))
+                    {
+                        Row summaryRow = instanceSummaryInformationTable.CreateRow(null);
+                        summaryRow[0] = (int)SummaryInformation.Transform.ValidationFlags;
+                        summaryRow[1] = "0";
+                    }
+                    else if (!summaryRows.Contains((int)SummaryInformation.Transform.Security))
+                    {
+                        Row summaryRow = instanceSummaryInformationTable.CreateRow(null);
+                        summaryRow[0] = (int)SummaryInformation.Transform.Security;
+                        summaryRow[1] = "4";
+                    }
+
+                    output.SubStorages.Add(new SubStorage(instanceId, instanceTransform));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Validate that there are no duplicate GUIDs in the output.
+        /// </summary>
+        /// <remarks>
+        /// Duplicate GUIDs without conditions are an error condition; with conditions, it's a
+        /// warning, as the conditions might be mutually exclusive.
+        /// </remarks>
+        private void ValidateComponentGuids(Output output)
+        {
+            Table componentTable = output.Tables["Component"];
+            if (null != componentTable)
+            {
+                Dictionary<string, bool> componentGuidConditions = new Dictionary<string, bool>(componentTable.Rows.Count);
+
+                foreach (ComponentRow row in componentTable.Rows)
+                {
+                    // we don't care about unmanaged components and if there's a * GUID remaining,
+                    // there's already an error that prevented it from being replaced with a real GUID.
+                    if (!String.IsNullOrEmpty(row.Guid) && "*" != row.Guid)
+                    {
+                        bool thisComponentHasCondition = !String.IsNullOrEmpty(row.Condition);
+                        bool allComponentsHaveConditions = thisComponentHasCondition;
+
+                        if (componentGuidConditions.ContainsKey(row.Guid))
+                        {
+                            allComponentsHaveConditions = componentGuidConditions[row.Guid] && thisComponentHasCondition;
+
+                            if (allComponentsHaveConditions)
+                            {
+                                Messaging.Instance.OnMessage(WixWarnings.DuplicateComponentGuidsMustHaveMutuallyExclusiveConditions(row.SourceLineNumbers, row.Component, row.Guid));
+                            }
+                            else
+                            {
+                                Messaging.Instance.OnMessage(WixErrors.DuplicateComponentGuids(row.SourceLineNumbers, row.Component, row.Guid));
+                            }
+                        }
+
+                        componentGuidConditions[row.Guid] = allComponentsHaveConditions;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Update Control and BBControl text by reading from files when necessary.
+        /// </summary>
+        /// <param name="output">Internal representation of the msi database to operate upon.</param>
+        private void UpdateControlText(Output output)
+        {
+            UpdateControlTextCommand command = new UpdateControlTextCommand();
+            command.BBControlTable = output.Tables["BBControl"];
+            command.WixBBControlTable = output.Tables["WixBBControl"];
+            command.ControlTable = output.Tables["Control"];
+            command.WixControlTable = output.Tables["WixControl"];
+            command.Execute();
+        }
+
+        private string ResolveMedia(MediaRow mediaRow, string mediaLayoutDirectory, string layoutDirectory)
+        {
+            string layout = null;
+
+            foreach (IBinderFileManager fileManager in this.FileManagers)
+            {
+                layout = fileManager.ResolveMedia(mediaRow, mediaLayoutDirectory, layoutDirectory);
+                if (!String.IsNullOrEmpty(layout))
+                {
+                    break;
+                }
+            }
+
+            // If no binder file manager resolved the layout, do the default behavior.
+            if (String.IsNullOrEmpty(layout))
+            {
+                if (String.IsNullOrEmpty(mediaLayoutDirectory))
+                {
+                    layout = layoutDirectory;
+                }
+                else if (Path.IsPathRooted(mediaLayoutDirectory))
+                {
+                    layout = mediaLayoutDirectory;
+                }
+                else
+                {
+                    layout = Path.Combine(layoutDirectory, mediaLayoutDirectory);
+                }
+            }
+
+            return layout;
+        }
+
+        /// <summary>
+        /// Creates the MSI/MSM/PCP database.
+        /// </summary>
+        /// <param name="output">Output to create database for.</param>
+        /// <param name="databaseFile">The database file to create.</param>
+        /// <param name="keepAddedColumns">Whether to keep columns added in a transform.</param>
+        /// <param name="useSubdirectory">Whether to use a subdirectory based on the <paramref name="databaseFile"/> file name for intermediate files.</param>
+        private void GenerateDatabase(Output output, string databaseFile, bool keepAddedColumns, bool useSubdirectory)
+        {
+            GenerateDatabaseCommand command = new GenerateDatabaseCommand();
+            command.Extensions = this.Extensions;
+            command.FileManagers = this.FileManagers;
+            command.Output = output;
+            command.OutputPath = databaseFile;
+            command.KeepAddedColumns = keepAddedColumns;
+            command.UseSubDirectory = useSubdirectory;
+            command.SuppressAddingValidationRows = this.SuppressAddingValidationRows;
+            command.TableDefinitions = this.TableDefinitions;
+            command.TempFilesLocation = this.TempFilesLocation;
+            command.Codepage = this.Codepage;
+            command.Execute();
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/BindTransformCommand.cs b/src/WixToolset.Core/Bind/BindTransformCommand.cs
new file mode 100644
index 00000000..e909f191
--- /dev/null
+++ b/src/WixToolset.Core/Bind/BindTransformCommand.cs
@@ -0,0 +1,473 @@
+// 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.Bind
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.IO;
+    using WixToolset.Data;
+    using WixToolset.Extensibility;
+    using WixToolset.Msi;
+    using WixToolset.Core.Native;
+
+    internal class BindTransformCommand : ICommand
+    {
+        public IEnumerable<IBinderExtension> Extensions { private get; set; }
+
+        public IEnumerable<IBinderFileManager> FileManagers { private get; set; }
+
+        public TableDefinitionCollection TableDefinitions { private get; set; }
+
+        public string TempFilesLocation { private get; set; }
+
+        public Output Transform { private get; set; }
+
+        public string OutputPath { private get; set; }
+
+        public void Execute()
+        {
+            int transformFlags = 0;
+
+            Output targetOutput = new Output(null);
+            Output updatedOutput = new Output(null);
+
+            // TODO: handle added columns
+
+            // to generate a localized transform, both the target and updated
+            // databases need to have the same code page. the only reason to
+            // set different code pages is to support localized primary key
+            // columns, but that would only support deleting rows. if this
+            // becomes necessary, define a PreviousCodepage property on the
+            // Output class and persist this throughout transform generation.
+            targetOutput.Codepage = this.Transform.Codepage;
+            updatedOutput.Codepage = this.Transform.Codepage;
+
+            // remove certain Property rows which will be populated from summary information values
+            string targetUpgradeCode = null;
+            string updatedUpgradeCode = null;
+
+            Table propertyTable = this.Transform.Tables["Property"];
+            if (null != propertyTable)
+            {
+                for (int i = propertyTable.Rows.Count - 1; i >= 0; i--)
+                {
+                    Row row = propertyTable.Rows[i];
+
+                    if ("ProductCode" == (string)row[0] || "ProductLanguage" == (string)row[0] || "ProductVersion" == (string)row[0] || "UpgradeCode" == (string)row[0])
+                    {
+                        propertyTable.Rows.RemoveAt(i);
+
+                        if ("UpgradeCode" == (string)row[0])
+                        {
+                            updatedUpgradeCode = (string)row[1];
+                        }
+                    }
+                }
+            }
+
+            Table targetSummaryInfo = targetOutput.EnsureTable(this.TableDefinitions["_SummaryInformation"]);
+            Table updatedSummaryInfo = updatedOutput.EnsureTable(this.TableDefinitions["_SummaryInformation"]);
+            Table targetPropertyTable = targetOutput.EnsureTable(this.TableDefinitions["Property"]);
+            Table updatedPropertyTable = updatedOutput.EnsureTable(this.TableDefinitions["Property"]);
+
+            // process special summary information values
+            foreach (Row row in this.Transform.Tables["_SummaryInformation"].Rows)
+            {
+                if ((int)SummaryInformation.Transform.CodePage == (int)row[0])
+                {
+                    // convert from a web name if provided
+                    string codePage = (string)row.Fields[1].Data;
+                    if (null == codePage)
+                    {
+                        codePage = "0";
+                    }
+                    else
+                    {
+                        codePage = Common.GetValidCodePage(codePage).ToString(CultureInfo.InvariantCulture);
+                    }
+
+                    string previousCodePage = (string)row.Fields[1].PreviousData;
+                    if (null == previousCodePage)
+                    {
+                        previousCodePage = "0";
+                    }
+                    else
+                    {
+                        previousCodePage = Common.GetValidCodePage(previousCodePage).ToString(CultureInfo.InvariantCulture);
+                    }
+
+                    Row targetCodePageRow = targetSummaryInfo.CreateRow(null);
+                    targetCodePageRow[0] = 1; // PID_CODEPAGE
+                    targetCodePageRow[1] = previousCodePage;
+
+                    Row updatedCodePageRow = updatedSummaryInfo.CreateRow(null);
+                    updatedCodePageRow[0] = 1; // PID_CODEPAGE
+                    updatedCodePageRow[1] = codePage;
+                }
+                else if ((int)SummaryInformation.Transform.TargetPlatformAndLanguage == (int)row[0] ||
+                         (int)SummaryInformation.Transform.UpdatedPlatformAndLanguage == (int)row[0])
+                {
+                    // the target language
+                    string[] propertyData = ((string)row[1]).Split(';');
+                    string lang = 2 == propertyData.Length ? propertyData[1] : "0";
+
+                    Table tempSummaryInfo = (int)SummaryInformation.Transform.TargetPlatformAndLanguage == (int)row[0] ? targetSummaryInfo : updatedSummaryInfo;
+                    Table tempPropertyTable = (int)SummaryInformation.Transform.TargetPlatformAndLanguage == (int)row[0] ? targetPropertyTable : updatedPropertyTable;
+
+                    Row productLanguageRow = tempPropertyTable.CreateRow(null);
+                    productLanguageRow[0] = "ProductLanguage";
+                    productLanguageRow[1] = lang;
+
+                    // set the platform;language on the MSI to be generated
+                    Row templateRow = tempSummaryInfo.CreateRow(null);
+                    templateRow[0] = 7; // PID_TEMPLATE
+                    templateRow[1] = (string)row[1];
+                }
+                else if ((int)SummaryInformation.Transform.ProductCodes == (int)row[0])
+                {
+                    string[] propertyData = ((string)row[1]).Split(';');
+
+                    Row targetProductCodeRow = targetPropertyTable.CreateRow(null);
+                    targetProductCodeRow[0] = "ProductCode";
+                    targetProductCodeRow[1] = propertyData[0].Substring(0, 38);
+
+                    Row targetProductVersionRow = targetPropertyTable.CreateRow(null);
+                    targetProductVersionRow[0] = "ProductVersion";
+                    targetProductVersionRow[1] = propertyData[0].Substring(38);
+
+                    Row updatedProductCodeRow = updatedPropertyTable.CreateRow(null);
+                    updatedProductCodeRow[0] = "ProductCode";
+                    updatedProductCodeRow[1] = propertyData[1].Substring(0, 38);
+
+                    Row updatedProductVersionRow = updatedPropertyTable.CreateRow(null);
+                    updatedProductVersionRow[0] = "ProductVersion";
+                    updatedProductVersionRow[1] = propertyData[1].Substring(38);
+
+                    // UpgradeCode is optional and may not exists in the target
+                    // or upgraded databases, so do not include a null-valued
+                    // UpgradeCode property.
+
+                    targetUpgradeCode = propertyData[2];
+                    if (!String.IsNullOrEmpty(targetUpgradeCode))
+                    {
+                        Row targetUpgradeCodeRow = targetPropertyTable.CreateRow(null);
+                        targetUpgradeCodeRow[0] = "UpgradeCode";
+                        targetUpgradeCodeRow[1] = targetUpgradeCode;
+
+                        // If the target UpgradeCode is specified, an updated
+                        // UpgradeCode is required.
+                        if (String.IsNullOrEmpty(updatedUpgradeCode))
+                        {
+                            updatedUpgradeCode = targetUpgradeCode;
+                        }
+                    }
+
+                    if (!String.IsNullOrEmpty(updatedUpgradeCode))
+                    {
+                        Row updatedUpgradeCodeRow = updatedPropertyTable.CreateRow(null);
+                        updatedUpgradeCodeRow[0] = "UpgradeCode";
+                        updatedUpgradeCodeRow[1] = updatedUpgradeCode;
+                    }
+                }
+                else if ((int)SummaryInformation.Transform.ValidationFlags == (int)row[0])
+                {
+                    transformFlags = Convert.ToInt32(row[1], CultureInfo.InvariantCulture);
+                }
+                else if ((int)SummaryInformation.Transform.Reserved11 == (int)row[0])
+                {
+                    // PID_LASTPRINTED should be null for transforms
+                    row.Operation = RowOperation.None;
+                }
+                else
+                {
+                    // add everything else as is
+                    Row targetRow = targetSummaryInfo.CreateRow(null);
+                    targetRow[0] = row[0];
+                    targetRow[1] = row[1];
+
+                    Row updatedRow = updatedSummaryInfo.CreateRow(null);
+                    updatedRow[0] = row[0];
+                    updatedRow[1] = row[1];
+                }
+            }
+
+            // Validate that both databases have an UpgradeCode if the
+            // authoring transform will validate the UpgradeCode; otherwise,
+            // MsiCreateTransformSummaryinfo() will fail with 1620.
+            if (((int)TransformFlags.ValidateUpgradeCode & transformFlags) != 0 &&
+                (String.IsNullOrEmpty(targetUpgradeCode) || String.IsNullOrEmpty(updatedUpgradeCode)))
+            {
+                Messaging.Instance.OnMessage(WixErrors.BothUpgradeCodesRequired());
+            }
+
+            string emptyFile = null;
+
+            foreach (Table table in this.Transform.Tables)
+            {
+                // Ignore unreal tables when building transforms except the _Stream table.
+                // These tables are ignored when generating the database so there is no reason
+                // to process them here.
+                if (table.Definition.Unreal && "_Streams" != table.Name)
+                {
+                    continue;
+                }
+
+                // process table operations
+                switch (table.Operation)
+                {
+                    case TableOperation.Add:
+                        updatedOutput.EnsureTable(table.Definition);
+                        break;
+                    case TableOperation.Drop:
+                        targetOutput.EnsureTable(table.Definition);
+                        continue;
+                    default:
+                        targetOutput.EnsureTable(table.Definition);
+                        updatedOutput.EnsureTable(table.Definition);
+                        break;
+                }
+
+                // process row operations
+                foreach (Row row in table.Rows)
+                {
+                    switch (row.Operation)
+                    {
+                        case RowOperation.Add:
+                            Table updatedTable = updatedOutput.EnsureTable(table.Definition);
+                            updatedTable.Rows.Add(row);
+                            continue;
+                        case RowOperation.Delete:
+                            Table targetTable = targetOutput.EnsureTable(table.Definition);
+                            targetTable.Rows.Add(row);
+
+                            // fill-in non-primary key values
+                            foreach (Field field in row.Fields)
+                            {
+                                if (!field.Column.PrimaryKey)
+                                {
+                                    if (ColumnType.Number == field.Column.Type && !field.Column.IsLocalizable)
+                                    {
+                                        field.Data = field.Column.MinValue;
+                                    }
+                                    else if (ColumnType.Object == field.Column.Type)
+                                    {
+                                        if (null == emptyFile)
+                                        {
+                                            emptyFile = Path.Combine(this.TempFilesLocation, "empty");
+                                        }
+
+                                        field.Data = emptyFile;
+                                    }
+                                    else
+                                    {
+                                        field.Data = "0";
+                                    }
+                                }
+                            }
+                            continue;
+                    }
+
+                    // Assure that the file table's sequence is populated
+                    if ("File" == table.Name)
+                    {
+                        foreach (Row fileRow in table.Rows)
+                        {
+                            if (null == fileRow[7])
+                            {
+                                if (RowOperation.Add == fileRow.Operation)
+                                {
+                                    Messaging.Instance.OnMessage(WixErrors.InvalidAddedFileRowWithoutSequence(fileRow.SourceLineNumbers, (string)fileRow[0]));
+                                    break;
+                                }
+
+                                // Set to 1 to prevent invalid IDT file from being generated
+                                fileRow[7] = 1;
+                            }
+                        }
+                    }
+
+                    // process modified and unmodified rows
+                    bool modifiedRow = false;
+                    Row targetRow = new Row(null, table.Definition);
+                    Row updatedRow = row;
+                    for (int i = 0; i < row.Fields.Length; i++)
+                    {
+                        Field updatedField = row.Fields[i];
+
+                        if (updatedField.Modified)
+                        {
+                            // set a different value in the target row to ensure this value will be modified during transform generation
+                            if (ColumnType.Number == updatedField.Column.Type && !updatedField.Column.IsLocalizable)
+                            {
+                                if (null == updatedField.Data || 1 != (int)updatedField.Data)
+                                {
+                                    targetRow[i] = 1;
+                                }
+                                else
+                                {
+                                    targetRow[i] = 2;
+                                }
+                            }
+                            else if (ColumnType.Object == updatedField.Column.Type)
+                            {
+                                if (null == emptyFile)
+                                {
+                                    emptyFile = Path.Combine(this.TempFilesLocation, "empty");
+                                }
+
+                                targetRow[i] = emptyFile;
+                            }
+                            else
+                            {
+                                if ("0" != (string)updatedField.Data)
+                                {
+                                    targetRow[i] = "0";
+                                }
+                                else
+                                {
+                                    targetRow[i] = "1";
+                                }
+                            }
+
+                            modifiedRow = true;
+                        }
+                        else if (ColumnType.Object == updatedField.Column.Type)
+                        {
+                            ObjectField objectField = (ObjectField)updatedField;
+
+                            // create an empty file for comparing against
+                            if (null == objectField.PreviousData)
+                            {
+                                if (null == emptyFile)
+                                {
+                                    emptyFile = Path.Combine(this.TempFilesLocation, "empty");
+                                }
+
+                                targetRow[i] = emptyFile;
+                                modifiedRow = true;
+                            }
+                            else if (!this.CompareFiles(objectField.PreviousData, (string)objectField.Data))
+                            {
+                                targetRow[i] = objectField.PreviousData;
+                                modifiedRow = true;
+                            }
+                        }
+                        else // unmodified
+                        {
+                            if (null != updatedField.Data)
+                            {
+                                targetRow[i] = updatedField.Data;
+                            }
+                        }
+                    }
+
+                    // modified rows and certain special rows go in the target and updated msi databases
+                    if (modifiedRow ||
+                        ("Property" == table.Name &&
+                            ("ProductCode" == (string)row[0] ||
+                            "ProductLanguage" == (string)row[0] ||
+                            "ProductVersion" == (string)row[0] ||
+                            "UpgradeCode" == (string)row[0])))
+                    {
+                        Table targetTable = targetOutput.EnsureTable(table.Definition);
+                        targetTable.Rows.Add(targetRow);
+
+                        Table updatedTable = updatedOutput.EnsureTable(table.Definition);
+                        updatedTable.Rows.Add(updatedRow);
+                    }
+                }
+            }
+
+            foreach (BinderExtension extension in this.Extensions)
+            {
+                extension.Finish(this.Transform);
+            }
+
+            // Any errors encountered up to this point can cause errors during generation.
+            if (Messaging.Instance.EncounteredError)
+            {
+                return;
+            }
+
+            string transformFileName = Path.GetFileNameWithoutExtension(this.OutputPath);
+            string targetDatabaseFile = Path.Combine(this.TempFilesLocation, String.Concat(transformFileName, "_target.msi"));
+            string updatedDatabaseFile = Path.Combine(this.TempFilesLocation, String.Concat(transformFileName, "_updated.msi"));
+
+            try
+            {
+                if (!String.IsNullOrEmpty(emptyFile))
+                {
+                    using (FileStream fileStream = File.Create(emptyFile))
+                    {
+                    }
+                }
+
+                this.GenerateDatabase(targetOutput, targetDatabaseFile, false);
+                this.GenerateDatabase(updatedOutput, updatedDatabaseFile, true);
+
+                // make sure the directory exists
+                Directory.CreateDirectory(Path.GetDirectoryName(this.OutputPath));
+
+                // create the transform file
+                using (Database targetDatabase = new Database(targetDatabaseFile, OpenDatabase.ReadOnly))
+                {
+                    using (Database updatedDatabase = new Database(updatedDatabaseFile, OpenDatabase.ReadOnly))
+                    {
+                        if (updatedDatabase.GenerateTransform(targetDatabase, this.OutputPath))
+                        {
+                            updatedDatabase.CreateTransformSummaryInfo(targetDatabase, this.OutputPath, (TransformErrorConditions)(transformFlags & 0xFFFF), (TransformValidations)((transformFlags >> 16) & 0xFFFF));
+                        }
+                        else
+                        {
+                            Messaging.Instance.OnMessage(WixErrors.NoDifferencesInTransform(this.Transform.SourceLineNumbers));
+                        }
+                    }
+                }
+            }
+            finally
+            {
+                if (!String.IsNullOrEmpty(emptyFile))
+                {
+                    File.Delete(emptyFile);
+                }
+            }
+        }
+
+        private bool CompareFiles(string targetFile, string updatedFile)
+        {
+            bool? compared = null;
+            foreach (IBinderFileManager fileManager in this.FileManagers)
+            {
+                compared = fileManager.CompareFiles(targetFile, updatedFile);
+                if (compared.HasValue)
+                {
+                    break;
+                }
+            }
+
+            if (!compared.HasValue)
+            {
+                throw new InvalidOperationException(); // TODO: something needs to be said here that none of the binder file managers returned a result.
+            }
+
+            return compared.Value;
+        }
+
+        private void GenerateDatabase(Output output, string outputPath, bool keepAddedColumns)
+        {
+            GenerateDatabaseCommand command = new GenerateDatabaseCommand();
+            command.Codepage = output.Codepage;
+            command.Extensions = this.Extensions;
+            command.FileManagers = this.FileManagers;
+            command.KeepAddedColumns = keepAddedColumns;
+            command.Output = output;
+            command.OutputPath = outputPath;
+            command.TableDefinitions = this.TableDefinitions;
+            command.TempFilesLocation = this.TempFilesLocation;
+            command.SuppressAddingValidationRows = true;
+            command.UseSubDirectory = true;
+            command.Execute();
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/Bundles/AutomaticallySlipstreamPatchesCommand.cs b/src/WixToolset.Core/Bind/Bundles/AutomaticallySlipstreamPatchesCommand.cs
new file mode 100644
index 00000000..eb02a983
--- /dev/null
+++ b/src/WixToolset.Core/Bind/Bundles/AutomaticallySlipstreamPatchesCommand.cs
@@ -0,0 +1,112 @@
+// 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.Bind.Bundles
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Linq;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+
+    internal class AutomaticallySlipstreamPatchesCommand : ICommand
+    {
+        public IEnumerable<PackageFacade> PackageFacades { private get; set; }
+
+        public Table WixBundlePatchTargetCodeTable { private get; set; }
+
+        public Table SlipstreamMspTable { private get; set; }
+
+        public void Execute()
+        {
+            List<WixBundleMsiPackageRow> msiPackages = new List<WixBundleMsiPackageRow>();
+            Dictionary<string, List<WixBundlePatchTargetCodeRow>> targetsProductCode = new Dictionary<string, List<WixBundlePatchTargetCodeRow>>();
+            Dictionary<string, List<WixBundlePatchTargetCodeRow>> targetsUpgradeCode = new Dictionary<string, List<WixBundlePatchTargetCodeRow>>();
+
+            foreach (PackageFacade facade in this.PackageFacades)
+            {
+                if (WixBundlePackageType.Msi == facade.Package.Type)
+                {
+                    // Keep track of all MSI packages.
+                    msiPackages.Add(facade.MsiPackage);
+                }
+                else if (WixBundlePackageType.Msp == facade.Package.Type && facade.MspPackage.Slipstream)
+                {
+                    IEnumerable<WixBundlePatchTargetCodeRow> patchTargetCodeRows = this.WixBundlePatchTargetCodeTable.RowsAs<WixBundlePatchTargetCodeRow>().Where(r => r.MspPackageId == facade.Package.WixChainItemId);
+
+                    // Index target ProductCodes and UpgradeCodes for slipstreamed MSPs.
+                    foreach (WixBundlePatchTargetCodeRow row in patchTargetCodeRows)
+                    {
+                        if (row.TargetsProductCode)
+                        {
+                            List<WixBundlePatchTargetCodeRow> rows;
+                            if (!targetsProductCode.TryGetValue(row.TargetCode, out rows))
+                            {
+                                rows = new List<WixBundlePatchTargetCodeRow>();
+                                targetsProductCode.Add(row.TargetCode, rows);
+                            }
+
+                            rows.Add(row);
+                        }
+                        else if (row.TargetsUpgradeCode)
+                        {
+                            List<WixBundlePatchTargetCodeRow> rows;
+                            if (!targetsUpgradeCode.TryGetValue(row.TargetCode, out rows))
+                            {
+                                rows = new List<WixBundlePatchTargetCodeRow>();
+                                targetsUpgradeCode.Add(row.TargetCode, rows);
+                            }
+                        }
+                    }
+                }
+            }
+
+            RowIndexedList<Row> slipstreamMspRows = new RowIndexedList<Row>(SlipstreamMspTable);
+
+            // Loop through the MSI and slipstream patches targeting it.
+            foreach (WixBundleMsiPackageRow msi in msiPackages)
+            {
+                List<WixBundlePatchTargetCodeRow> rows;
+                if (targetsProductCode.TryGetValue(msi.ProductCode, out rows))
+                {
+                    foreach (WixBundlePatchTargetCodeRow row in rows)
+                    {
+                        Debug.Assert(row.TargetsProductCode);
+                        Debug.Assert(!row.TargetsUpgradeCode);
+
+                        Row slipstreamMspRow = SlipstreamMspTable.CreateRow(row.SourceLineNumbers, false);
+                        slipstreamMspRow[0] = msi.ChainPackageId;
+                        slipstreamMspRow[1] = row.MspPackageId;
+
+                        if (slipstreamMspRows.TryAdd(slipstreamMspRow))
+                        {
+                            SlipstreamMspTable.Rows.Add(slipstreamMspRow);
+                        }
+                    }
+
+                    rows = null;
+                }
+
+                if (!String.IsNullOrEmpty(msi.UpgradeCode) && targetsUpgradeCode.TryGetValue(msi.UpgradeCode, out rows))
+                {
+                    foreach (WixBundlePatchTargetCodeRow row in rows)
+                    {
+                        Debug.Assert(!row.TargetsProductCode);
+                        Debug.Assert(row.TargetsUpgradeCode);
+
+                        Row slipstreamMspRow = SlipstreamMspTable.CreateRow(row.SourceLineNumbers, false);
+                        slipstreamMspRow[0] = msi.ChainPackageId;
+                        slipstreamMspRow[1] = row.MspPackageId;
+
+                        if (slipstreamMspRows.TryAdd(slipstreamMspRow))
+                        {
+                            SlipstreamMspTable.Rows.Add(slipstreamMspRow);
+                        }
+                    }
+
+                    rows = null;
+                }
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/Bundles/BurnCommon.cs b/src/WixToolset.Core/Bind/Bundles/BurnCommon.cs
new file mode 100644
index 00000000..8cb07791
--- /dev/null
+++ b/src/WixToolset.Core/Bind/Bundles/BurnCommon.cs
@@ -0,0 +1,378 @@
+// 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.Bind.Bundles
+{
+    using System;
+    using System.Diagnostics;
+    using System.IO;
+    using WixToolset.Data;
+
+    /// <summary>
+    /// Common functionality for Burn PE Writer & Reader for the WiX toolset.
+    /// </summary>
+    /// <remarks>This class encapsulates common functionality related to 
+    /// bundled/chained setup packages.</remarks>
+    /// <example>
+    /// </example>
+    internal abstract class BurnCommon : IDisposable
+    {
+        public const string BurnNamespace = "http://wixtoolset.org/schemas/v4/2008/Burn";
+        public const string BurnUXContainerEmbeddedIdFormat = "u{0}";
+        public const string BurnUXContainerPayloadIdFormat = "p{0}";
+        public const string BurnAttachedContainerEmbeddedIdFormat = "a{0}";
+
+        // See WinNT.h for details about the PE format, including the
+        // structure and offsets for IMAGE_DOS_HEADER, IMAGE_NT_HEADERS32,
+        // IMAGE_FILE_HEADER, etc.
+        protected const UInt32 IMAGE_DOS_HEADER_SIZE = 64;
+        protected const UInt32 IMAGE_DOS_HEADER_OFFSET_MAGIC = 0;
+        protected const UInt32 IMAGE_DOS_HEADER_OFFSET_NTHEADER = 60;
+
+        protected const UInt32 IMAGE_NT_HEADER_SIZE = 24; // signature DWORD (4) + IMAGE_FILE_HEADER (20)
+        protected const UInt32 IMAGE_NT_HEADER_OFFSET_SIGNATURE = 0;
+        protected const UInt32 IMAGE_NT_HEADER_OFFSET_NUMBEROFSECTIONS = 6;
+        protected const UInt32 IMAGE_NT_HEADER_OFFSET_SIZEOFOPTIONALHEADER = 20;
+
+        protected const UInt32 IMAGE_OPTIONAL_OFFSET_CHECKSUM = 4 * 16; // checksum is 16 DWORDs into IMAGE_OPTIONAL_HEADER which is right after the IMAGE_NT_HEADER.
+        protected const UInt32 IMAGE_OPTIONAL_NEGATIVE_OFFSET_CERTIFICATETABLE = (IMAGE_DATA_DIRECTORY_SIZE * (IMAGE_NUMBEROF_DIRECTORY_ENTRIES - IMAGE_DIRECTORY_ENTRY_SECURITY));
+
+        protected const UInt32 IMAGE_SECTION_HEADER_SIZE = 40;
+        protected const UInt32 IMAGE_SECTION_HEADER_OFFSET_NAME = 0;
+        protected const UInt32 IMAGE_SECTION_HEADER_OFFSET_VIRTUALSIZE = 8;
+        protected const UInt32 IMAGE_SECTION_HEADER_OFFSET_SIZEOFRAWDATA = 16;
+        protected const UInt32 IMAGE_SECTION_HEADER_OFFSET_POINTERTORAWDATA = 20;
+
+        protected const UInt32 IMAGE_DATA_DIRECTORY_SIZE = 8; // struct of two DWORDs.
+        protected const UInt32 IMAGE_DIRECTORY_ENTRY_SECURITY = 4;
+        protected const UInt32 IMAGE_NUMBEROF_DIRECTORY_ENTRIES = 16;
+
+        protected const UInt16 IMAGE_DOS_SIGNATURE = 0x5A4D;
+        protected const UInt32 IMAGE_NT_SIGNATURE = 0x00004550;
+        protected const UInt64 IMAGE_SECTION_WIXBURN_NAME = 0x6E7275627869772E; // ".wixburn", as a qword.
+
+        // The ".wixburn" section contains:
+        //    0- 3:  magic number
+        //    4- 7:  version
+        //    8-23:  bundle GUID
+        //   24-27:  engine (stub) size
+        //   28-31:  original checksum
+        //   32-35:  original signature offset
+        //   36-39:  original signature size
+        //   40-43:  container type (1 = CAB)
+        //   44-47:  container count
+        //   48-51:  byte count of manifest + UX container
+        //   52-55:  byte count of attached container
+        protected const UInt32 BURN_SECTION_OFFSET_MAGIC = 0;
+        protected const UInt32 BURN_SECTION_OFFSET_VERSION = 4;
+        protected const UInt32 BURN_SECTION_OFFSET_BUNDLEGUID = 8;
+        protected const UInt32 BURN_SECTION_OFFSET_STUBSIZE = 24;
+        protected const UInt32 BURN_SECTION_OFFSET_ORIGINALCHECKSUM = 28;
+        protected const UInt32 BURN_SECTION_OFFSET_ORIGINALSIGNATUREOFFSET = 32;
+        protected const UInt32 BURN_SECTION_OFFSET_ORIGINALSIGNATURESIZE = 36;
+        protected const UInt32 BURN_SECTION_OFFSET_FORMAT = 40;
+        protected const UInt32 BURN_SECTION_OFFSET_COUNT = 44;
+        protected const UInt32 BURN_SECTION_OFFSET_UXSIZE = 48;
+        protected const UInt32 BURN_SECTION_OFFSET_ATTACHEDCONTAINERSIZE = 52;
+        protected const UInt32 BURN_SECTION_SIZE = BURN_SECTION_OFFSET_ATTACHEDCONTAINERSIZE + 4; // last field + sizeof(DWORD)
+
+        protected const UInt32 BURN_SECTION_MAGIC = 0x00f14300;
+        protected const UInt32 BURN_SECTION_VERSION = 0x00000002;
+
+        protected string fileExe;
+        protected UInt32 peOffset = UInt32.MaxValue;
+        protected UInt16 sections = UInt16.MaxValue;
+        protected UInt32 firstSectionOffset = UInt32.MaxValue;
+        protected UInt32 checksumOffset;
+        protected UInt32 certificateTableSignatureOffset;
+        protected UInt32 certificateTableSignatureSize;
+        protected UInt32 wixburnDataOffset = UInt32.MaxValue;
+
+        // TODO: does this enum exist in another form somewhere?
+        /// <summary>
+        /// The types of attached containers that BurnWriter supports.
+        /// </summary>
+        public enum Container
+        {
+            Nothing = 0,
+            UX,
+            Attached
+        }
+
+        /// <summary>
+        /// Creates a BurnCommon for re-writing a PE file.
+        /// </summary>
+        /// <param name="fileExe">File to modify in-place.</param>
+        /// <param name="bundleGuid">GUID for the bundle.</param>
+        public BurnCommon(string fileExe)
+        {
+            this.fileExe = fileExe;
+        }
+
+        public UInt32 Checksum { get; protected set; }
+        public UInt32 SignatureOffset { get; protected set; }
+        public UInt32 SignatureSize { get; protected set; }
+        public UInt32 Version { get; protected set; }
+        public UInt32 StubSize { get; protected set; }
+        public UInt32 OriginalChecksum { get; protected set; }
+        public UInt32 OriginalSignatureOffset { get; protected set; }
+        public UInt32 OriginalSignatureSize { get; protected set; }
+        public UInt32 EngineSize { get; protected set; }
+        public UInt32 ContainerCount { get; protected set; }
+        public UInt32 UXAddress { get; protected set; }
+        public UInt32 UXSize { get; protected set; }
+        public UInt32 AttachedContainerAddress { get; protected set; }
+        public UInt32 AttachedContainerSize { get; protected set; }
+
+        public void Dispose()
+        {
+            Dispose(true);
+
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// Copies one stream to another.
+        /// </summary>
+        /// <param name="input">Input stream.</param>
+        /// <param name="output">Output stream.</param>
+        /// <param name="size">Optional count of bytes to copy. 0 indicates whole input stream from current should be copied.</param>
+        protected static int CopyStream(Stream input, Stream output, int size)
+        {
+            byte[] bytes = new byte[4096];
+            int total = 0;
+            int read = 0;
+            do
+            {
+                read = Math.Min(bytes.Length, size - total);
+                read = input.Read(bytes, 0, read);
+                if (0 == read)
+                {
+                    break;
+                }
+
+                output.Write(bytes, 0, read);
+                total += read;
+            } while (0 == size || total < size);
+
+            return total;
+        }
+
+        /// <summary>
+        /// Initialize the common information about a Burn engine.
+        /// </summary>
+        /// <param name="reader">Binary reader open against a Burn engine.</param>
+        /// <returns>True if initialized.</returns>
+        protected bool Initialize(BinaryReader reader)
+        {
+            if (!GetWixburnSectionInfo(reader))
+            {
+                return false;
+            }
+
+            reader.BaseStream.Seek(this.wixburnDataOffset, SeekOrigin.Begin);
+            byte[] bytes = reader.ReadBytes((int)BURN_SECTION_SIZE);
+            UInt32 uint32 = 0;
+
+            uint32 = BurnCommon.ReadUInt32(bytes, BURN_SECTION_OFFSET_MAGIC);
+            if (BURN_SECTION_MAGIC != uint32)
+            {
+                Messaging.Instance.OnMessage(WixErrors.InvalidBundle(this.fileExe));
+                return false;
+            }
+
+            this.Version = BurnCommon.ReadUInt32(bytes, BURN_SECTION_OFFSET_VERSION);
+            if (BURN_SECTION_VERSION != this.Version)
+            {
+                Messaging.Instance.OnMessage(WixErrors.BundleTooNew(this.fileExe, this.Version));
+                return false;
+            }
+
+            uint32 = BurnCommon.ReadUInt32(bytes, BURN_SECTION_OFFSET_FORMAT); // We only know how to deal with CABs right now
+            if (1 != uint32)
+            {
+                Messaging.Instance.OnMessage(WixErrors.InvalidBundle(this.fileExe));
+                return false;
+            }
+
+            this.StubSize = BurnCommon.ReadUInt32(bytes, BURN_SECTION_OFFSET_STUBSIZE);
+            this.OriginalChecksum = BurnCommon.ReadUInt32(bytes, BURN_SECTION_OFFSET_ORIGINALCHECKSUM);
+            this.OriginalSignatureOffset = BurnCommon.ReadUInt32(bytes, BURN_SECTION_OFFSET_ORIGINALSIGNATUREOFFSET);
+            this.OriginalSignatureSize = BurnCommon.ReadUInt32(bytes, BURN_SECTION_OFFSET_ORIGINALSIGNATURESIZE);
+
+            this.ContainerCount = BurnCommon.ReadUInt32(bytes, BURN_SECTION_OFFSET_COUNT);
+            this.UXAddress = this.StubSize;
+            this.UXSize = BurnCommon.ReadUInt32(bytes, BURN_SECTION_OFFSET_UXSIZE);
+
+            // If there is an original signature use that to determine the engine size.
+            if (0 < this.OriginalSignatureOffset)
+            {
+                this.EngineSize = this.OriginalSignatureOffset + this.OriginalSignatureSize;
+            }
+            else if (0 < this.SignatureOffset && 2 > this.ContainerCount) // if there is a signature and no attached containers, use the current signature.
+            {
+                this.EngineSize = this.SignatureOffset + this.SignatureSize;
+            }
+            else // just use the stub and UX container as the size of the engine.
+            {
+                this.EngineSize = this.StubSize + this.UXSize;
+            }
+
+            this.AttachedContainerAddress = this.ContainerCount > 1 ? this.EngineSize : 0;
+            this.AttachedContainerSize = this.ContainerCount > 1 ? BurnCommon.ReadUInt32(bytes, BURN_SECTION_OFFSET_ATTACHEDCONTAINERSIZE) : 0;
+
+            return true;
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+        }
+
+        /// <summary>
+        /// Finds the ".wixburn" section in the current exe.
+        /// </summary>
+        /// <returns>true if the ".wixburn" section is successfully found; false otherwise</returns>
+        private bool GetWixburnSectionInfo(BinaryReader reader)
+        {
+            if (UInt32.MaxValue == this.wixburnDataOffset)
+            {
+                if (!EnsureNTHeader(reader))
+                {
+                    return false;
+                }
+
+                UInt32 wixburnSectionOffset = UInt32.MaxValue;
+                byte[] bytes = new byte[IMAGE_SECTION_HEADER_SIZE];
+
+                reader.BaseStream.Seek(this.firstSectionOffset, SeekOrigin.Begin);
+                for (UInt16 sectionIndex = 0; sectionIndex < this.sections; ++sectionIndex)
+                {
+                    reader.Read(bytes, 0, bytes.Length);
+
+                    if (IMAGE_SECTION_WIXBURN_NAME == BurnCommon.ReadUInt64(bytes, IMAGE_SECTION_HEADER_OFFSET_NAME))
+                    {
+                        wixburnSectionOffset = this.firstSectionOffset + (IMAGE_SECTION_HEADER_SIZE * sectionIndex);
+                        break;
+                    }
+                }
+
+                if (UInt32.MaxValue == wixburnSectionOffset)
+                {
+                    Messaging.Instance.OnMessage(WixErrors.StubMissingWixburnSection(this.fileExe));
+                    return false;
+                }
+
+                // we need 56 bytes for the manifest header, which is always going to fit in 
+                // the smallest alignment (512 bytes), but just to be paranoid...
+                if (BURN_SECTION_SIZE > BurnCommon.ReadUInt32(bytes, IMAGE_SECTION_HEADER_OFFSET_SIZEOFRAWDATA))
+                {
+                    Messaging.Instance.OnMessage(WixErrors.StubWixburnSectionTooSmall(this.fileExe));
+                    return false;
+                }
+
+                this.wixburnDataOffset = BurnCommon.ReadUInt32(bytes, IMAGE_SECTION_HEADER_OFFSET_POINTERTORAWDATA);
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Checks for a valid Windows PE signature (IMAGE_NT_SIGNATURE) in the current exe.
+        /// </summary>
+        /// <returns>true if the exe is a Windows executable; false otherwise</returns>
+        private bool EnsureNTHeader(BinaryReader reader)
+        {
+            if (UInt32.MaxValue == this.firstSectionOffset)
+            {
+                if (!EnsureDosHeader(reader))
+                {
+                    return false;
+                }
+
+                reader.BaseStream.Seek(this.peOffset, SeekOrigin.Begin);
+                byte[] bytes = reader.ReadBytes((int)IMAGE_NT_HEADER_SIZE);
+
+                // Verify the NT signature...
+                if (IMAGE_NT_SIGNATURE != BurnCommon.ReadUInt32(bytes, IMAGE_NT_HEADER_OFFSET_SIGNATURE))
+                {
+                    Messaging.Instance.OnMessage(WixErrors.InvalidStubExe(this.fileExe));
+                    return false;
+                }
+
+                ushort sizeOptionalHeader = BurnCommon.ReadUInt16(bytes, IMAGE_NT_HEADER_OFFSET_SIZEOFOPTIONALHEADER);
+
+                this.sections = BurnCommon.ReadUInt16(bytes, IMAGE_NT_HEADER_OFFSET_NUMBEROFSECTIONS);
+                this.firstSectionOffset = this.peOffset + IMAGE_NT_HEADER_SIZE + sizeOptionalHeader;
+
+                this.checksumOffset = this.peOffset + IMAGE_NT_HEADER_SIZE + IMAGE_OPTIONAL_OFFSET_CHECKSUM;
+                this.certificateTableSignatureOffset = this.peOffset + IMAGE_NT_HEADER_SIZE + sizeOptionalHeader - IMAGE_OPTIONAL_NEGATIVE_OFFSET_CERTIFICATETABLE;
+                this.certificateTableSignatureSize = this.certificateTableSignatureOffset + 4; // size is in the DWORD after the offset.
+
+                bytes = reader.ReadBytes(sizeOptionalHeader);
+                this.Checksum = BurnCommon.ReadUInt32(bytes, IMAGE_OPTIONAL_OFFSET_CHECKSUM);
+                this.SignatureOffset = BurnCommon.ReadUInt32(bytes, sizeOptionalHeader - IMAGE_OPTIONAL_NEGATIVE_OFFSET_CERTIFICATETABLE);
+                this.SignatureSize = BurnCommon.ReadUInt32(bytes, sizeOptionalHeader - IMAGE_OPTIONAL_NEGATIVE_OFFSET_CERTIFICATETABLE + 4);
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Checks for a valid DOS header in the current exe.
+        /// </summary>
+        /// <returns>true if the exe starts with a DOS stub; false otherwise</returns>
+        private bool EnsureDosHeader(BinaryReader reader)
+        {
+            if (UInt32.MaxValue == this.peOffset)
+            {
+                byte[] bytes = reader.ReadBytes((int)IMAGE_DOS_HEADER_SIZE);
+
+                // Verify the DOS 'MZ' signature.
+                if (IMAGE_DOS_SIGNATURE != BurnCommon.ReadUInt16(bytes, IMAGE_DOS_HEADER_OFFSET_MAGIC))
+                {
+                    Messaging.Instance.OnMessage(WixErrors.InvalidStubExe(this.fileExe));
+                    return false;
+                }
+
+                this.peOffset = BurnCommon.ReadUInt32(bytes, IMAGE_DOS_HEADER_OFFSET_NTHEADER);
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Reads a UInt16 value in little-endian format from an offset in an array of bytes.
+        /// </summary>
+        /// <param name="bytes">Array from which to read.</param>
+        /// <param name="offset">Beginning offset from which to read.</param>
+        /// <returns>value at offset</returns>
+        private static UInt16 ReadUInt16(byte[] bytes, UInt32 offset)
+        {
+            Debug.Assert(offset + 2 <= bytes.Length);
+            return (UInt16)(bytes[offset] + (bytes[offset + 1] << 8));
+        }
+
+        /// <summary>
+        /// Reads a UInt32 value in little-endian format from an offset in an array of bytes.
+        /// </summary>
+        /// <param name="bytes">Array from which to read.</param>
+        /// <param name="offset">Beginning offset from which to read.</param>
+        /// <returns>value at offset</returns>
+        private static UInt32 ReadUInt32(byte[] bytes, UInt32 offset)
+        {
+            Debug.Assert(offset + 4 <= bytes.Length);
+            return (UInt32)(bytes[offset] + (bytes[offset + 1] << 8) + (bytes[offset + 2] << 16) + (bytes[offset + 3] << 24));
+        }
+
+        /// <summary>
+        /// Reads a UInt64 value in little-endian format from an offset in an array of bytes.
+        /// </summary>
+        /// <param name="bytes">Array from which to read.</param>
+        /// <param name="offset">Beginning offset from which to read.</param>
+        /// <returns>value at offset</returns>
+        private static UInt64 ReadUInt64(byte[] bytes, UInt32 offset)
+        {
+            Debug.Assert(offset + 8 <= bytes.Length);
+            return BurnCommon.ReadUInt32(bytes, offset) + ((UInt64)(BurnCommon.ReadUInt32(bytes, offset + 4)) << 32);
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/Bundles/BurnReader.cs b/src/WixToolset.Core/Bind/Bundles/BurnReader.cs
new file mode 100644
index 00000000..f6d7a197
--- /dev/null
+++ b/src/WixToolset.Core/Bind/Bundles/BurnReader.cs
@@ -0,0 +1,210 @@
+// 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.Bind.Bundles
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Xml;
+    using WixToolset.Cab;
+
+    /// <summary>
+    /// Burn PE reader for the WiX toolset.
+    /// </summary>
+    /// <remarks>This class encapsulates reading from a stub EXE with containers attached
+    /// for dissecting bundled/chained setup packages.</remarks>
+    /// <example>
+    /// using (BurnReader reader = BurnReader.Open(fileExe, this.core, guid))
+    /// {
+    ///     reader.ExtractUXContainer(file1, tempFolder);
+    /// }
+    /// </example>
+    internal class BurnReader : BurnCommon
+    {
+        private bool disposed;
+
+        private bool invalidBundle;
+        private BinaryReader binaryReader;
+        private List<DictionaryEntry> attachedContainerPayloadNames;
+
+        /// <summary>
+        /// Creates a BurnReader for reading a PE file.
+        /// </summary>
+        /// <param name="fileExe">File to read.</param>
+        private BurnReader(string fileExe)
+            : base(fileExe)
+        {
+            this.attachedContainerPayloadNames = new List<DictionaryEntry>();
+        }
+
+        /// <summary>
+        /// Gets the underlying stream.
+        /// </summary>
+        public Stream Stream
+        {
+            get
+            {
+                return (null != this.binaryReader) ? this.binaryReader.BaseStream : null;
+            }
+        }
+
+        /// <summary>
+        /// Opens a Burn reader.
+        /// </summary>
+        /// <param name="fileExe">Path to file.</param>
+        /// <returns>Burn reader.</returns>
+        public static BurnReader Open(string fileExe)
+        {
+            BurnReader reader = new BurnReader(fileExe);
+
+            reader.binaryReader = new BinaryReader(File.Open(fileExe, FileMode.Open, FileAccess.Read, FileShare.Read | FileShare.Delete));
+            if (!reader.Initialize(reader.binaryReader))
+            {
+                reader.invalidBundle = true;
+            }
+
+            return reader;
+        }
+
+        /// <summary>
+        /// Gets the UX container from the exe and extracts its contents to the output directory.
+        /// </summary>
+        /// <param name="outputDirectory">Directory to write extracted files to.</param>
+        /// <returns>True if successful, false otherwise</returns>
+        public bool ExtractUXContainer(string outputDirectory, string tempDirectory)
+        {
+            // No UX container to extract
+            if (this.UXAddress == 0 || this.UXSize == 0)
+            {
+                return false;
+            }
+
+            if (this.invalidBundle)
+            {
+                return false;
+            }
+
+            Directory.CreateDirectory(outputDirectory);
+            string tempCabPath = Path.Combine(tempDirectory, "ux.cab");
+            string manifestOriginalPath = Path.Combine(outputDirectory, "0");
+            string manifestPath = Path.Combine(outputDirectory, "manifest.xml");
+
+            this.binaryReader.BaseStream.Seek(this.UXAddress, SeekOrigin.Begin);
+            using (Stream tempCab = File.Open(tempCabPath, FileMode.Create, FileAccess.Write))
+            {
+                BurnCommon.CopyStream(this.binaryReader.BaseStream, tempCab, (int)this.UXSize);
+            }
+
+            using (WixExtractCab extract = new WixExtractCab())
+            {
+                extract.Extract(tempCabPath, outputDirectory);
+            }
+
+            Directory.CreateDirectory(Path.GetDirectoryName(manifestPath));
+            File.Delete(manifestPath);
+            File.Move(manifestOriginalPath, manifestPath);
+
+            XmlDocument document = new XmlDocument();
+            document.Load(manifestPath);
+            XmlNamespaceManager namespaceManager = new XmlNamespaceManager(document.NameTable);
+            namespaceManager.AddNamespace("burn", BurnCommon.BurnNamespace);
+            XmlNodeList uxPayloads = document.SelectNodes("/burn:BurnManifest/burn:UX/burn:Payload", namespaceManager);
+            XmlNodeList payloads = document.SelectNodes("/burn:BurnManifest/burn:Payload", namespaceManager);
+
+            foreach (XmlNode uxPayload in uxPayloads)
+            {
+                XmlNode sourcePathNode = uxPayload.Attributes.GetNamedItem("SourcePath");
+                XmlNode filePathNode = uxPayload.Attributes.GetNamedItem("FilePath");
+
+                string sourcePath = Path.Combine(outputDirectory, sourcePathNode.Value);
+                string destinationPath = Path.Combine(outputDirectory, filePathNode.Value);
+
+                Directory.CreateDirectory(Path.GetDirectoryName(destinationPath));
+                File.Delete(destinationPath);
+                File.Move(sourcePath, destinationPath);
+            }
+
+            foreach (XmlNode payload in payloads)
+            {
+                XmlNode sourcePathNode = payload.Attributes.GetNamedItem("SourcePath");
+                XmlNode filePathNode = payload.Attributes.GetNamedItem("FilePath");
+                XmlNode packagingNode = payload.Attributes.GetNamedItem("Packaging");
+
+                string sourcePath = sourcePathNode.Value;
+                string destinationPath = filePathNode.Value;
+                string packaging = packagingNode.Value;
+
+                if (packaging.Equals("embedded", StringComparison.OrdinalIgnoreCase))
+                {
+                    this.attachedContainerPayloadNames.Add(new DictionaryEntry(sourcePath, destinationPath));
+                }
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Gets the attached container from the exe and extracts its contents to the output directory.
+        /// </summary>
+        /// <param name="outputDirectory">Directory to write extracted files to.</param>
+        /// <returns>True if successful, false otherwise</returns>
+        public bool ExtractAttachedContainer(string outputDirectory, string tempDirectory)
+        {
+            // No attached container to extract
+            if (this.AttachedContainerAddress == 0 || this.AttachedContainerSize == 0)
+            {
+                return false;
+            }
+
+            if (this.invalidBundle)
+            {
+                return false;
+            }
+
+            Directory.CreateDirectory(outputDirectory);
+            string tempCabPath = Path.Combine(tempDirectory, "attached.cab");
+
+            this.binaryReader.BaseStream.Seek(this.AttachedContainerAddress, SeekOrigin.Begin);
+            using (Stream tempCab = File.Open(tempCabPath, FileMode.Create, FileAccess.Write))
+            {
+                BurnCommon.CopyStream(this.binaryReader.BaseStream, tempCab, (int)this.AttachedContainerSize);
+            }
+
+            using (WixExtractCab extract = new WixExtractCab())
+            {
+                extract.Extract(tempCabPath, outputDirectory);
+            }
+
+            foreach (DictionaryEntry entry in this.attachedContainerPayloadNames)
+            {
+                string sourcePath = Path.Combine(outputDirectory, (string)entry.Key);
+                string destinationPath = Path.Combine(outputDirectory, (string)entry.Value);
+
+                Directory.CreateDirectory(Path.GetDirectoryName(destinationPath));
+                File.Delete(destinationPath);
+                File.Move(sourcePath, destinationPath);
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Dispose object.
+        /// </summary>
+        /// <param name="disposing">True when releasing managed objects.</param>
+        protected override void Dispose(bool disposing)
+        {
+            if (!this.disposed)
+            {
+                if (disposing && this.binaryReader != null)
+                {
+                    this.binaryReader.Close();
+                    this.binaryReader = null;
+                }
+
+                this.disposed = true;
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/Bundles/BurnWriter.cs b/src/WixToolset.Core/Bind/Bundles/BurnWriter.cs
new file mode 100644
index 00000000..bc0baf46
--- /dev/null
+++ b/src/WixToolset.Core/Bind/Bundles/BurnWriter.cs
@@ -0,0 +1,239 @@
+// 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.Bind.Bundles
+{
+    using System;
+    using System.Diagnostics;
+    using System.IO;
+    using WixToolset.Data;
+
+    /// <summary>
+    /// Burn PE writer for the WiX toolset.
+    /// </summary>
+    /// <remarks>This class encapsulates reading/writing to a stub EXE for
+    /// creating bundled/chained setup packages.</remarks>
+    /// <example>
+    /// using (BurnWriter writer = new BurnWriter(fileExe, this.core, guid))
+    /// {
+    ///     writer.AppendContainer(file1, BurnWriter.Container.UX);
+    ///     writer.AppendContainer(file2, BurnWriter.Container.Attached);
+    /// }
+    /// </example>
+    internal class BurnWriter : BurnCommon
+    {
+        private bool disposed;
+        private bool invalidBundle;
+        private BinaryWriter binaryWriter;
+
+        /// <summary>
+        /// Creates a BurnWriter for re-writing a PE file.
+        /// </summary>
+        /// <param name="fileExe">File to modify in-place.</param>
+        /// <param name="bundleGuid">GUID for the bundle.</param>
+        private BurnWriter(string fileExe)
+            : base(fileExe)
+        {
+        }
+
+        /// <summary>
+        /// Opens a Burn writer.
+        /// </summary>
+        /// <param name="fileExe">Path to file.</param>
+        /// <returns>Burn writer.</returns>
+        public static BurnWriter Open(string fileExe)
+        {
+            BurnWriter writer = new BurnWriter(fileExe);
+
+            using (BinaryReader binaryReader = new BinaryReader(File.Open(fileExe, FileMode.Open, FileAccess.Read, FileShare.Read | FileShare.Delete)))
+            {
+                if (!writer.Initialize(binaryReader))
+                {
+                    writer.invalidBundle = true;
+                }
+            }
+
+            if (!writer.invalidBundle)
+            {
+                writer.binaryWriter = new BinaryWriter(File.Open(fileExe, FileMode.Open, FileAccess.ReadWrite, FileShare.Read | FileShare.Delete));
+            }
+
+            return writer;
+        }
+
+        /// <summary>
+        /// Update the ".wixburn" section data.
+        /// </summary>
+        /// <param name="stubSize">Size of the stub engine "burn.exe".</param>
+        /// <param name="bundleId">Unique identifier for this bundle.</param>
+        /// <returns></returns>
+        public bool InitializeBundleSectionData(long stubSize, Guid bundleId)
+        {
+            if (this.invalidBundle)
+            {
+                return false;
+            }
+
+            this.WriteToBurnSectionOffset(BURN_SECTION_OFFSET_MAGIC, BURN_SECTION_MAGIC);
+            this.WriteToBurnSectionOffset(BURN_SECTION_OFFSET_VERSION, BURN_SECTION_VERSION);
+
+            Messaging.Instance.OnMessage(WixVerboses.BundleGuid(bundleId.ToString("B")));
+            this.binaryWriter.BaseStream.Seek(this.wixburnDataOffset + BURN_SECTION_OFFSET_BUNDLEGUID, SeekOrigin.Begin);
+            this.binaryWriter.Write(bundleId.ToByteArray());
+
+            this.StubSize = (uint)stubSize;
+
+            this.WriteToBurnSectionOffset(BURN_SECTION_OFFSET_STUBSIZE, this.StubSize);
+            this.WriteToBurnSectionOffset(BURN_SECTION_OFFSET_ORIGINALCHECKSUM, 0);
+            this.WriteToBurnSectionOffset(BURN_SECTION_OFFSET_ORIGINALSIGNATUREOFFSET, 0);
+            this.WriteToBurnSectionOffset(BURN_SECTION_OFFSET_ORIGINALSIGNATURESIZE, 0);
+            this.WriteToBurnSectionOffset(BURN_SECTION_OFFSET_FORMAT, 1); // Hard-coded to CAB for now.
+            this.WriteToBurnSectionOffset(BURN_SECTION_OFFSET_COUNT, 0);
+            this.WriteToBurnSectionOffset(BURN_SECTION_OFFSET_UXSIZE, 0);
+            this.WriteToBurnSectionOffset(BURN_SECTION_OFFSET_ATTACHEDCONTAINERSIZE, 0);
+            this.binaryWriter.BaseStream.Flush();
+
+            this.EngineSize = this.StubSize;
+
+            return true;
+        }
+
+        /// <summary>
+        /// Appends a UX or Attached container to the exe and updates the ".wixburn" section data to point to it.
+        /// </summary>
+        /// <param name="fileContainer">File path to append to the current exe.</param>
+        /// <param name="container">Container section represented by the fileContainer.</param>
+        /// <returns>true if the container data is successfully appended; false otherwise</returns>
+        public bool AppendContainer(string fileContainer, BurnCommon.Container container)
+        {
+            using (FileStream reader = File.OpenRead(fileContainer))
+            {
+                return this.AppendContainer(reader, reader.Length, container);
+            }
+        }
+
+        /// <summary>
+        /// Appends a UX or Attached container to the exe and updates the ".wixburn" section data to point to it.
+        /// </summary>
+        /// <param name="containerStream">File stream to append to the current exe.</param>
+        /// <param name="containerSize">Size of container to append.</param>
+        /// <param name="container">Container section represented by the fileContainer.</param>
+        /// <returns>true if the container data is successfully appended; false otherwise</returns>
+        public bool AppendContainer(Stream containerStream, long containerSize, BurnCommon.Container container)
+        {
+            UInt32 burnSectionCount = 0;
+            UInt32 burnSectionOffsetSize = 0;
+
+            switch (container)
+            {
+                case Container.UX:
+                    burnSectionCount = 1;
+                    burnSectionOffsetSize = BURN_SECTION_OFFSET_UXSIZE;
+                    // TODO: verify that the size in the section data is 0 or the same size.
+                    this.EngineSize += (uint)containerSize;
+                    this.UXSize = (uint)containerSize;
+                    break;
+
+                case Container.Attached:
+                    burnSectionCount = 2;
+                    burnSectionOffsetSize = BURN_SECTION_OFFSET_ATTACHEDCONTAINERSIZE;
+                    // TODO: verify that the size in the section data is 0 or the same size.
+                    this.AttachedContainerSize = (uint)containerSize;
+                    break;
+
+                default:
+                    Debug.Assert(false);
+                    return false;
+            }
+
+            return AppendContainer(containerStream, (UInt32)containerSize, burnSectionOffsetSize, burnSectionCount);
+        }
+
+        public void RememberThenResetSignature()
+        {
+            if (this.invalidBundle)
+            {
+                return;
+            }
+
+            this.OriginalChecksum = this.Checksum;
+            this.OriginalSignatureOffset = this.SignatureOffset;
+            this.OriginalSignatureSize = this.SignatureSize;
+
+            this.WriteToBurnSectionOffset(BURN_SECTION_OFFSET_ORIGINALCHECKSUM, this.OriginalChecksum);
+            this.WriteToBurnSectionOffset(BURN_SECTION_OFFSET_ORIGINALSIGNATUREOFFSET, this.OriginalSignatureOffset);
+            this.WriteToBurnSectionOffset(BURN_SECTION_OFFSET_ORIGINALSIGNATURESIZE, this.OriginalSignatureSize);
+
+            this.Checksum = 0;
+            this.SignatureOffset = 0;
+            this.SignatureSize = 0;
+
+            this.WriteToOffset(this.checksumOffset, this.Checksum);
+            this.WriteToOffset(this.certificateTableSignatureOffset, this.SignatureOffset);
+            this.WriteToOffset(this.certificateTableSignatureSize, this.SignatureSize);
+        }
+
+        /// <summary>
+        /// Dispose object.
+        /// </summary>
+        /// <param name="disposing">True when releasing managed objects.</param>
+        protected override void Dispose(bool disposing)
+        {
+            if (!this.disposed)
+            {
+                if (disposing && this.binaryWriter != null)
+                {
+                    this.binaryWriter.Close();
+                    this.binaryWriter = null;
+                }
+
+                this.disposed = true;
+            }
+        }
+
+        /// <summary>
+        /// Appends a container to the exe and updates the ".wixburn" section data to point to it.
+        /// </summary>
+        /// <param name="containerStream">File stream to append to the current exe.</param>
+        /// <param name="burnSectionOffsetSize">Offset of size field for this container in ".wixburn" section data.</param>
+        /// <returns>true if the container data is successfully appended; false otherwise</returns>
+        private bool AppendContainer(Stream containerStream, UInt32 containerSize, UInt32 burnSectionOffsetSize, UInt32 burnSectionCount)
+        {
+            if (this.invalidBundle)
+            {
+                return false;
+            }
+
+            // Update the ".wixburn" section data
+            this.WriteToBurnSectionOffset(BURN_SECTION_OFFSET_COUNT, burnSectionCount);
+            this.WriteToBurnSectionOffset(burnSectionOffsetSize, containerSize);
+
+            // Append the container to the end of the existing bits.
+            this.binaryWriter.BaseStream.Seek(0, SeekOrigin.End);
+            BurnCommon.CopyStream(containerStream, this.binaryWriter.BaseStream, (int)containerSize);
+            this.binaryWriter.BaseStream.Flush();
+
+            return true;
+        }
+
+        /// <summary>
+        /// Writes the value to an offset in the Burn section data.
+        /// </summary>
+        /// <param name="offset">Offset in to the Burn section data.</param>
+        /// <param name="value">Value to write.</param>
+        private void WriteToBurnSectionOffset(uint offset, uint value)
+        {
+            this.WriteToOffset(this.wixburnDataOffset + offset, value);
+        }
+
+        /// <summary>
+        /// Writes the value to an offset in the Burn stub.
+        /// </summary>
+        /// <param name="offset">Offset in to the Burn stub.</param>
+        /// <param name="value">Value to write.</param>
+        private void WriteToOffset(uint offset, uint value)
+        {
+            this.binaryWriter.BaseStream.Seek((int)offset, SeekOrigin.Begin);
+            this.binaryWriter.Write(value);
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/Bundles/CreateBootstrapperApplicationManifestCommand.cs b/src/WixToolset.Core/Bind/Bundles/CreateBootstrapperApplicationManifestCommand.cs
new file mode 100644
index 00000000..1040b394
--- /dev/null
+++ b/src/WixToolset.Core/Bind/Bundles/CreateBootstrapperApplicationManifestCommand.cs
@@ -0,0 +1,241 @@
+// 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.Bind.Bundles
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Globalization;
+    using System.IO;
+    using System.Text;
+    using System.Xml;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+
+    internal class CreateBootstrapperApplicationManifestCommand : ICommand
+    {
+        public WixBundleRow BundleRow { private get; set; }
+
+        public IEnumerable<PackageFacade> ChainPackages { private get; set; }
+
+        public int LastUXPayloadIndex { private get; set; }
+
+        public IEnumerable<WixBundleMsiFeatureRow> MsiFeatures { private get; set; }
+
+        public Output Output { private get; set; }
+
+        public RowDictionary<WixBundlePayloadRow> Payloads { private get; set; }
+
+        public TableDefinitionCollection TableDefinitions { private get; set; }
+
+        public string TempFilesLocation { private get; set; }
+
+        public WixBundlePayloadRow BootstrapperApplicationManifestPayloadRow { get; private set; }
+
+        public void Execute()
+        {
+            this.GenerateBAManifestBundleTables();
+
+            this.GenerateBAManifestMsiFeatureTables();
+
+            this.GenerateBAManifestPackageTables();
+
+            this.GenerateBAManifestPayloadTables();
+
+            string baManifestPath = Path.Combine(this.TempFilesLocation, "wix-badata.xml");
+
+            this.CreateBootstrapperApplicationManifest(baManifestPath);
+
+            this.BootstrapperApplicationManifestPayloadRow = this.CreateBootstrapperApplicationManifestPayloadRow(baManifestPath);
+        }
+
+        private void GenerateBAManifestBundleTables()
+        {
+            Table wixBundlePropertiesTable = this.Output.EnsureTable(this.TableDefinitions["WixBundleProperties"]);
+
+            Row row = wixBundlePropertiesTable.CreateRow(this.BundleRow.SourceLineNumbers);
+            row[0] = this.BundleRow.Name;
+            row[1] = this.BundleRow.LogPathVariable;
+            row[2] = (YesNoDefaultType.Yes == this.BundleRow.Compressed) ? "yes" : "no";
+            row[3] = this.BundleRow.BundleId.ToString("B");
+            row[4] = this.BundleRow.UpgradeCode;
+            row[5] = this.BundleRow.PerMachine ? "yes" : "no";
+        }
+
+        private void GenerateBAManifestPackageTables()
+        {
+            Table wixPackagePropertiesTable = this.Output.EnsureTable(this.TableDefinitions["WixPackageProperties"]);
+
+            foreach (PackageFacade package in this.ChainPackages)
+            {
+                WixBundlePayloadRow packagePayload = this.Payloads[package.Package.PackagePayload];
+
+                Row row = wixPackagePropertiesTable.CreateRow(package.Package.SourceLineNumbers);
+                row[0] = package.Package.WixChainItemId;
+                row[1] = (YesNoType.Yes == package.Package.Vital) ? "yes" : "no";
+                row[2] = package.Package.DisplayName;
+                row[3] = package.Package.Description;
+                row[4] = package.Package.Size.ToString(CultureInfo.InvariantCulture); // TODO: DownloadSize (compressed) (what does this mean when it's embedded?)
+                row[5] = package.Package.Size.ToString(CultureInfo.InvariantCulture); // Package.Size (uncompressed)
+                row[6] = package.Package.InstallSize.Value.ToString(CultureInfo.InvariantCulture); // InstallSize (required disk space)
+                row[7] = package.Package.Type.ToString();
+                row[8] = package.Package.Permanent ? "yes" : "no";
+                row[9] = package.Package.LogPathVariable;
+                row[10] = package.Package.RollbackLogPathVariable;
+                row[11] = (PackagingType.Embedded == packagePayload.Packaging) ? "yes" : "no";
+
+                if (WixBundlePackageType.Msi == package.Package.Type)
+                {
+                    row[12] = package.MsiPackage.DisplayInternalUI ? "yes" : "no";
+
+                    if (!String.IsNullOrEmpty(package.MsiPackage.ProductCode))
+                    {
+                        row[13] = package.MsiPackage.ProductCode;
+                    }
+
+                    if (!String.IsNullOrEmpty(package.MsiPackage.UpgradeCode))
+                    {
+                        row[14] = package.MsiPackage.UpgradeCode;
+                    }
+                }
+                else if (WixBundlePackageType.Msp == package.Package.Type)
+                {
+                    row[12] = package.MspPackage.DisplayInternalUI ? "yes" : "no";
+
+                    if (!String.IsNullOrEmpty(package.MspPackage.PatchCode))
+                    {
+                        row[13] = package.MspPackage.PatchCode;
+                    }
+                }
+
+                if (!String.IsNullOrEmpty(package.Package.Version))
+                {
+                    row[15] = package.Package.Version;
+                }
+
+                if (!String.IsNullOrEmpty(package.Package.InstallCondition))
+                {
+                    row[16] = package.Package.InstallCondition;
+                }
+
+                switch (package.Package.Cache)
+                {
+                    case YesNoAlwaysType.No:
+                        row[17] = "no";
+                        break;
+                    case YesNoAlwaysType.Yes:
+                        row[17] = "yes";
+                        break;
+                    case YesNoAlwaysType.Always:
+                        row[17] = "always";
+                        break;
+                }
+            }
+        }
+
+        private void GenerateBAManifestMsiFeatureTables()
+        {
+            Table wixPackageFeatureInfoTable = this.Output.EnsureTable(this.TableDefinitions["WixPackageFeatureInfo"]);
+
+            foreach (WixBundleMsiFeatureRow feature in this.MsiFeatures)
+            {
+                Row row = wixPackageFeatureInfoTable.CreateRow(feature.SourceLineNumbers);
+                row[0] = feature.ChainPackageId;
+                row[1] = feature.Name;
+                row[2] = Convert.ToString(feature.Size, CultureInfo.InvariantCulture);
+                row[3] = feature.Parent;
+                row[4] = feature.Title;
+                row[5] = feature.Description;
+                row[6] = Convert.ToString(feature.Display, CultureInfo.InvariantCulture);
+                row[7] = Convert.ToString(feature.Level, CultureInfo.InvariantCulture);
+                row[8] = feature.Directory;
+                row[9] = Convert.ToString(feature.Attributes, CultureInfo.InvariantCulture);
+            }
+
+        }
+
+        private void GenerateBAManifestPayloadTables()
+        {
+            Table wixPayloadPropertiesTable = this.Output.EnsureTable(this.TableDefinitions["WixPayloadProperties"]);
+
+            foreach (WixBundlePayloadRow payload in this.Payloads.Values)
+            {
+                WixPayloadPropertiesRow row = (WixPayloadPropertiesRow)wixPayloadPropertiesTable.CreateRow(payload.SourceLineNumbers);
+                row.Id = payload.Id;
+                row.Package = payload.Package;
+                row.Container = payload.Container;
+                row.Name = payload.Name;
+                row.Size = payload.FileSize.ToString();
+                row.DownloadUrl = payload.DownloadUrl;
+                row.LayoutOnly = payload.LayoutOnly ? "yes" : "no";
+            }
+        }
+
+        private void CreateBootstrapperApplicationManifest(string path)
+        {
+            using (XmlTextWriter writer = new XmlTextWriter(path, Encoding.Unicode))
+            {
+                writer.Formatting = Formatting.Indented;
+                writer.WriteStartDocument();
+                writer.WriteStartElement("BootstrapperApplicationData", "http://wixtoolset.org/schemas/v4/2010/BootstrapperApplicationData");
+
+                foreach (Table table in this.Output.Tables)
+                {
+                    if (table.Definition.BootstrapperApplicationData)
+                    {
+                        // We simply assert that the table (and field) name is valid, because
+                        // this is up to the extension developer to get right. An author will
+                        // only affect the attribute value, and that will get properly escaped.
+#if DEBUG
+                        Debug.Assert(Common.IsIdentifier(table.Name));
+                        foreach (ColumnDefinition column in table.Definition.Columns)
+                        {
+                            Debug.Assert(Common.IsIdentifier(column.Name));
+                        }
+#endif // DEBUG
+
+                        foreach (Row row in table.Rows)
+                        {
+                            writer.WriteStartElement(table.Name);
+
+                            foreach (Field field in row.Fields)
+                            {
+                                if (null != field.Data)
+                                {
+                                    writer.WriteAttributeString(field.Column.Name, field.Data.ToString());
+                                }
+                            }
+
+                            writer.WriteEndElement();
+                        }
+                    }
+                }
+
+                writer.WriteEndElement();
+                writer.WriteEndDocument();
+            }
+        }
+
+        private WixBundlePayloadRow CreateBootstrapperApplicationManifestPayloadRow(string baManifestPath)
+        {
+            Table payloadTable = this.Output.EnsureTable(this.TableDefinitions["WixBundlePayload"]);
+            WixBundlePayloadRow row = (WixBundlePayloadRow)payloadTable.CreateRow(this.BundleRow.SourceLineNumbers);
+            row.Id = Common.GenerateIdentifier("ux", "BootstrapperApplicationData.xml");
+            row.Name = "BootstrapperApplicationData.xml";
+            row.SourceFile = baManifestPath;
+            row.Compressed = YesNoDefaultType.Yes;
+            row.UnresolvedSourceFile = baManifestPath;
+            row.Container = Compiler.BurnUXContainerId;
+            row.EmbeddedId = String.Format(CultureInfo.InvariantCulture, BurnCommon.BurnUXContainerEmbeddedIdFormat, this.LastUXPayloadIndex);
+            row.Packaging = PackagingType.Embedded;
+
+            FileInfo fileInfo = new FileInfo(row.SourceFile);
+
+            row.FileSize = (int)fileInfo.Length;
+
+            row.Hash = Common.GetFileHash(fileInfo.FullName);
+
+            return row;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/Bundles/CreateBurnManifestCommand.cs b/src/WixToolset.Core/Bind/Bundles/CreateBurnManifestCommand.cs
new file mode 100644
index 00000000..7bc708a3
--- /dev/null
+++ b/src/WixToolset.Core/Bind/Bundles/CreateBurnManifestCommand.cs
@@ -0,0 +1,686 @@
+// 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.Bind.Bundles
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Globalization;
+    using System.Linq;
+    using System.Text;
+    using System.Xml;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+    using WixToolset.Extensibility;
+
+    internal class CreateBurnManifestCommand : ICommand
+    {
+        public IEnumerable<IBinderFileManager> FileManagers { private get; set; }
+
+        public Output Output { private get; set; }
+
+        public string ExecutableName { private get; set; }
+
+        public WixBundleRow BundleInfo { private get; set; }
+
+        public WixChainRow Chain { private get; set; }
+
+        public string OutputPath { private get; set; }
+
+        public IEnumerable<WixBundleRollbackBoundaryRow> RollbackBoundaries { private get; set; }
+
+        public IEnumerable<PackageFacade> OrderedPackages { private get; set; }
+
+        public IEnumerable<WixSearchInfo> OrderedSearches { private get; set; }
+
+        public Dictionary<string, WixBundlePayloadRow> Payloads { private get; set; }
+
+        public Dictionary<string, WixBundleContainerRow> Containers { private get; set; }
+
+        public IEnumerable<WixBundlePayloadRow> UXContainerPayloads { private get; set; }
+
+        public IEnumerable<WixBundleCatalogRow> Catalogs { private get; set; }
+
+        public void Execute()
+        {
+            using (XmlTextWriter writer = new XmlTextWriter(this.OutputPath, Encoding.UTF8))
+            {
+                writer.WriteStartDocument();
+
+                writer.WriteStartElement("BurnManifest", BurnCommon.BurnNamespace);
+
+                // Write the condition, if there is one
+                if (null != this.BundleInfo.Condition)
+                {
+                    writer.WriteElementString("Condition", this.BundleInfo.Condition);
+                }
+
+                // Write the log element if default logging wasn't disabled.
+                if (!String.IsNullOrEmpty(this.BundleInfo.LogPrefix))
+                {
+                    writer.WriteStartElement("Log");
+                    if (!String.IsNullOrEmpty(this.BundleInfo.LogPathVariable))
+                    {
+                        writer.WriteAttributeString("PathVariable", this.BundleInfo.LogPathVariable);
+                    }
+                    writer.WriteAttributeString("Prefix", this.BundleInfo.LogPrefix);
+                    writer.WriteAttributeString("Extension", this.BundleInfo.LogExtension);
+                    writer.WriteEndElement();
+                }
+
+
+                // Get update if specified.
+                WixBundleUpdateRow updateRow = this.Output.Tables["WixBundleUpdate"].RowsAs<WixBundleUpdateRow>().FirstOrDefault();
+
+                if (null != updateRow)
+                {
+                    writer.WriteStartElement("Update");
+                    writer.WriteAttributeString("Location", updateRow.Location);
+                    writer.WriteEndElement(); // </Update>
+                }
+
+                // Write the RelatedBundle elements
+
+                // For the related bundles with duplicated identifiers the second instance is ignored (i.e. the Duplicates
+                // enumeration in the index row list is not used).
+                RowIndexedList<WixRelatedBundleRow> relatedBundles = new RowIndexedList<WixRelatedBundleRow>(this.Output.Tables["WixRelatedBundle"]);
+
+                foreach (WixRelatedBundleRow relatedBundle in relatedBundles)
+                {
+                    writer.WriteStartElement("RelatedBundle");
+                    writer.WriteAttributeString("Id", relatedBundle.Id);
+                    writer.WriteAttributeString("Action", Convert.ToString(relatedBundle.Action, CultureInfo.InvariantCulture));
+                    writer.WriteEndElement();
+                }
+
+                // Write the variables
+                IEnumerable<WixBundleVariableRow> variables = this.Output.Tables["WixBundleVariable"].RowsAs<WixBundleVariableRow>();
+
+                foreach (WixBundleVariableRow variable in variables)
+                {
+                    writer.WriteStartElement("Variable");
+                    writer.WriteAttributeString("Id", variable.Id);
+                    if (null != variable.Type)
+                    {
+                        writer.WriteAttributeString("Value", variable.Value);
+                        writer.WriteAttributeString("Type", variable.Type);
+                    }
+                    writer.WriteAttributeString("Hidden", variable.Hidden ? "yes" : "no");
+                    writer.WriteAttributeString("Persisted", variable.Persisted ? "yes" : "no");
+                    writer.WriteEndElement();
+                }
+
+                // Write the searches
+                foreach (WixSearchInfo searchinfo in this.OrderedSearches)
+                {
+                    searchinfo.WriteXml(writer);
+                }
+
+                // write the UX element
+                writer.WriteStartElement("UX");
+                if (!String.IsNullOrEmpty(this.BundleInfo.SplashScreenBitmapPath))
+                {
+                    writer.WriteAttributeString("SplashScreen", "yes");
+                }
+
+                // write the UX allPayloads...
+                foreach (WixBundlePayloadRow payload in this.UXContainerPayloads)
+                {
+                    writer.WriteStartElement("Payload");
+                    this.WriteBurnManifestPayloadAttributes(writer, payload, true, this.Payloads);
+                    writer.WriteEndElement();
+                }
+
+                writer.WriteEndElement(); // </UX>
+
+                // write the catalog elements
+                if (this.Catalogs.Any())
+                {
+                    foreach (WixBundleCatalogRow catalog in this.Catalogs)
+                    {
+                        writer.WriteStartElement("Catalog");
+                        writer.WriteAttributeString("Id", catalog.Id);
+                        writer.WriteAttributeString("Payload", catalog.Payload);
+                        writer.WriteEndElement();
+                    }
+                }
+
+                foreach (WixBundleContainerRow container in this.Containers.Values)
+                {
+                    if (!String.IsNullOrEmpty(container.WorkingPath) && Compiler.BurnUXContainerId != container.Id)
+                    {
+                        writer.WriteStartElement("Container");
+                        this.WriteBurnManifestContainerAttributes(writer, this.ExecutableName, container);
+                        writer.WriteEndElement();
+                    }
+                }
+
+                foreach (WixBundlePayloadRow payload in this.Payloads.Values)
+                {
+                    if (PackagingType.Embedded == payload.Packaging && Compiler.BurnUXContainerId != payload.Container)
+                    {
+                        writer.WriteStartElement("Payload");
+                        this.WriteBurnManifestPayloadAttributes(writer, payload, true, this.Payloads);
+                        writer.WriteEndElement();
+                    }
+                    else if (PackagingType.External == payload.Packaging)
+                    {
+                        writer.WriteStartElement("Payload");
+                        this.WriteBurnManifestPayloadAttributes(writer, payload, false, this.Payloads);
+                        writer.WriteEndElement();
+                    }
+                }
+
+                foreach (WixBundleRollbackBoundaryRow rollbackBoundary in this.RollbackBoundaries)
+                {
+                    writer.WriteStartElement("RollbackBoundary");
+                    writer.WriteAttributeString("Id", rollbackBoundary.ChainPackageId);
+                    writer.WriteAttributeString("Vital", YesNoType.Yes == rollbackBoundary.Vital ? "yes" : "no");
+                    writer.WriteAttributeString("Transaction", YesNoType.Yes == rollbackBoundary.Transaction ? "yes" : "no");
+                    writer.WriteEndElement();
+                }
+
+                // Write the registration information...
+                writer.WriteStartElement("Registration");
+
+                writer.WriteAttributeString("Id", this.BundleInfo.BundleId.ToString("B"));
+                writer.WriteAttributeString("ExecutableName", this.ExecutableName);
+                writer.WriteAttributeString("PerMachine", this.BundleInfo.PerMachine ? "yes" : "no");
+                writer.WriteAttributeString("Tag", this.BundleInfo.Tag);
+                writer.WriteAttributeString("Version", this.BundleInfo.Version);
+                writer.WriteAttributeString("ProviderKey", this.BundleInfo.ProviderKey);
+
+                writer.WriteStartElement("Arp");
+                writer.WriteAttributeString("Register", (0 < this.BundleInfo.DisableModify && this.BundleInfo.DisableRemove) ? "no" : "yes"); // do not register if disabled modify and remove.
+                writer.WriteAttributeString("DisplayName", this.BundleInfo.Name);
+                writer.WriteAttributeString("DisplayVersion", this.BundleInfo.Version);
+
+                if (!String.IsNullOrEmpty(this.BundleInfo.Publisher))
+                {
+                    writer.WriteAttributeString("Publisher", this.BundleInfo.Publisher);
+                }
+
+                if (!String.IsNullOrEmpty(this.BundleInfo.HelpLink))
+                {
+                    writer.WriteAttributeString("HelpLink", this.BundleInfo.HelpLink);
+                }
+
+                if (!String.IsNullOrEmpty(this.BundleInfo.HelpTelephone))
+                {
+                    writer.WriteAttributeString("HelpTelephone", this.BundleInfo.HelpTelephone);
+                }
+
+                if (!String.IsNullOrEmpty(this.BundleInfo.AboutUrl))
+                {
+                    writer.WriteAttributeString("AboutUrl", this.BundleInfo.AboutUrl);
+                }
+
+                if (!String.IsNullOrEmpty(this.BundleInfo.UpdateUrl))
+                {
+                    writer.WriteAttributeString("UpdateUrl", this.BundleInfo.UpdateUrl);
+                }
+
+                if (!String.IsNullOrEmpty(this.BundleInfo.ParentName))
+                {
+                    writer.WriteAttributeString("ParentDisplayName", this.BundleInfo.ParentName);
+                }
+
+                if (1 == this.BundleInfo.DisableModify)
+                {
+                    writer.WriteAttributeString("DisableModify", "yes");
+                }
+                else if (2 == this.BundleInfo.DisableModify)
+                {
+                    writer.WriteAttributeString("DisableModify", "button");
+                }
+
+                if (this.BundleInfo.DisableRemove)
+                {
+                    writer.WriteAttributeString("DisableRemove", "yes");
+                }
+                writer.WriteEndElement(); // </Arp>
+
+                // Get update registration if specified.
+                WixUpdateRegistrationRow updateRegistrationInfo = this.Output.Tables["WixUpdateRegistration"].RowsAs<WixUpdateRegistrationRow>().FirstOrDefault();
+
+                if (null != updateRegistrationInfo)
+                {
+                    writer.WriteStartElement("Update"); // <Update>
+                    writer.WriteAttributeString("Manufacturer", updateRegistrationInfo.Manufacturer);
+
+                    if (!String.IsNullOrEmpty(updateRegistrationInfo.Department))
+                    {
+                        writer.WriteAttributeString("Department", updateRegistrationInfo.Department);
+                    }
+
+                    if (!String.IsNullOrEmpty(updateRegistrationInfo.ProductFamily))
+                    {
+                        writer.WriteAttributeString("ProductFamily", updateRegistrationInfo.ProductFamily);
+                    }
+
+                    writer.WriteAttributeString("Name", updateRegistrationInfo.Name);
+                    writer.WriteAttributeString("Classification", updateRegistrationInfo.Classification);
+                    writer.WriteEndElement(); // </Update>
+                }
+
+                IEnumerable<Row> bundleTags = this.Output.Tables["WixBundleTag"].RowsAs<Row>();
+
+                foreach (Row row in bundleTags)
+                {
+                    writer.WriteStartElement("SoftwareTag");
+                    writer.WriteAttributeString("Filename", (string)row[0]);
+                    writer.WriteAttributeString("Regid", (string)row[1]);
+                    writer.WriteCData((string)row[4]);
+                    writer.WriteEndElement();
+                }
+
+                writer.WriteEndElement(); // </Register>
+
+                // write the Chain...
+                writer.WriteStartElement("Chain");
+                if (this.Chain.DisableRollback)
+                {
+                    writer.WriteAttributeString("DisableRollback", "yes");
+                }
+
+                if (this.Chain.DisableSystemRestore)
+                {
+                    writer.WriteAttributeString("DisableSystemRestore", "yes");
+                }
+
+                if (this.Chain.ParallelCache)
+                {
+                    writer.WriteAttributeString("ParallelCache", "yes");
+                }
+
+                // Index a few tables by package.
+                ILookup<string, WixBundlePatchTargetCodeRow> targetCodesByPatch = this.Output.Tables["WixBundlePatchTargetCode"].RowsAs<WixBundlePatchTargetCodeRow>().ToLookup(r => r.MspPackageId);
+                ILookup<string, WixBundleMsiFeatureRow> msiFeaturesByPackage = this.Output.Tables["WixBundleMsiFeature"].RowsAs<WixBundleMsiFeatureRow>().ToLookup(r => r.ChainPackageId);
+                ILookup<string, WixBundleMsiPropertyRow> msiPropertiesByPackage = this.Output.Tables["WixBundleMsiProperty"].RowsAs<WixBundleMsiPropertyRow>().ToLookup(r => r.ChainPackageId);
+                ILookup<string, WixBundlePayloadRow> payloadsByPackage = this.Payloads.Values.ToLookup(p => p.Package);
+                ILookup<string, WixBundleRelatedPackageRow> relatedPackagesByPackage = this.Output.Tables["WixBundleRelatedPackage"].RowsAs<WixBundleRelatedPackageRow>().ToLookup(r => r.ChainPackageId);
+                ILookup<string, WixBundleSlipstreamMspRow> slipstreamMspsByPackage = this.Output.Tables["WixBundleSlipstreamMsp"].RowsAs<WixBundleSlipstreamMspRow>().ToLookup(r => r.ChainPackageId);
+                ILookup<string, WixBundlePackageExitCodeRow> exitCodesByPackage = this.Output.Tables["WixBundlePackageExitCode"].RowsAs<WixBundlePackageExitCodeRow>().ToLookup(r => r.ChainPackageId);
+                ILookup<string, WixBundlePackageCommandLineRow> commandLinesByPackage = this.Output.Tables["WixBundlePackageCommandLine"].RowsAs<WixBundlePackageCommandLineRow>().ToLookup(r => r.ChainPackageId);
+
+                // Build up the list of target codes from all the MSPs in the chain.
+                List<WixBundlePatchTargetCodeRow> targetCodes = new List<WixBundlePatchTargetCodeRow>();
+
+                foreach (PackageFacade package in this.OrderedPackages)
+                {
+                    writer.WriteStartElement(String.Format(CultureInfo.InvariantCulture, "{0}Package", package.Package.Type));
+
+                    writer.WriteAttributeString("Id", package.Package.WixChainItemId);
+
+                    switch (package.Package.Cache)
+                    {
+                        case YesNoAlwaysType.No:
+                            writer.WriteAttributeString("Cache", "no");
+                            break;
+                        case YesNoAlwaysType.Yes:
+                            writer.WriteAttributeString("Cache", "yes");
+                            break;
+                        case YesNoAlwaysType.Always:
+                            writer.WriteAttributeString("Cache", "always");
+                            break;
+                    }
+
+                    writer.WriteAttributeString("CacheId", package.Package.CacheId);
+                    writer.WriteAttributeString("InstallSize", Convert.ToString(package.Package.InstallSize));
+                    writer.WriteAttributeString("Size", Convert.ToString(package.Package.Size));
+                    writer.WriteAttributeString("PerMachine", YesNoDefaultType.Yes == package.Package.PerMachine ? "yes" : "no");
+                    writer.WriteAttributeString("Permanent", package.Package.Permanent ? "yes" : "no");
+                    writer.WriteAttributeString("Vital", (YesNoType.Yes == package.Package.Vital) ? "yes" : "no");
+
+                    if (null != package.Package.RollbackBoundary)
+                    {
+                        writer.WriteAttributeString("RollbackBoundaryForward", package.Package.RollbackBoundary);
+                    }
+
+                    if (!String.IsNullOrEmpty(package.Package.RollbackBoundaryBackward))
+                    {
+                        writer.WriteAttributeString("RollbackBoundaryBackward", package.Package.RollbackBoundaryBackward);
+                    }
+
+                    if (!String.IsNullOrEmpty(package.Package.LogPathVariable))
+                    {
+                        writer.WriteAttributeString("LogPathVariable", package.Package.LogPathVariable);
+                    }
+
+                    if (!String.IsNullOrEmpty(package.Package.RollbackLogPathVariable))
+                    {
+                        writer.WriteAttributeString("RollbackLogPathVariable", package.Package.RollbackLogPathVariable);
+                    }
+
+                    if (!String.IsNullOrEmpty(package.Package.InstallCondition))
+                    {
+                        writer.WriteAttributeString("InstallCondition", package.Package.InstallCondition);
+                    }
+
+                    if (WixBundlePackageType.Exe == package.Package.Type)
+                    {
+                        writer.WriteAttributeString("DetectCondition", package.ExePackage.DetectCondition);
+                        writer.WriteAttributeString("InstallArguments", package.ExePackage.InstallCommand);
+                        writer.WriteAttributeString("UninstallArguments", package.ExePackage.UninstallCommand);
+                        writer.WriteAttributeString("RepairArguments", package.ExePackage.RepairCommand);
+                        writer.WriteAttributeString("Repairable", package.ExePackage.Repairable ? "yes" : "no");
+                        if (!String.IsNullOrEmpty(package.ExePackage.ExeProtocol))
+                        {
+                            writer.WriteAttributeString("Protocol", package.ExePackage.ExeProtocol);
+                        }
+                    }
+                    else if (WixBundlePackageType.Msi == package.Package.Type)
+                    {
+                        writer.WriteAttributeString("ProductCode", package.MsiPackage.ProductCode);
+                        writer.WriteAttributeString("Language", package.MsiPackage.ProductLanguage.ToString(CultureInfo.InvariantCulture));
+                        writer.WriteAttributeString("Version", package.MsiPackage.ProductVersion);
+                        writer.WriteAttributeString("DisplayInternalUI", package.MsiPackage.DisplayInternalUI ? "yes" : "no");
+                        if (!String.IsNullOrEmpty(package.MsiPackage.UpgradeCode))
+                        {
+                            writer.WriteAttributeString("UpgradeCode", package.MsiPackage.UpgradeCode);
+                        }
+                    }
+                    else if (WixBundlePackageType.Msp == package.Package.Type)
+                    {
+                        writer.WriteAttributeString("PatchCode", package.MspPackage.PatchCode);
+                        writer.WriteAttributeString("PatchXml", package.MspPackage.PatchXml);
+                        writer.WriteAttributeString("DisplayInternalUI", package.MspPackage.DisplayInternalUI ? "yes" : "no");
+
+                        // If there is still a chance that all of our patches will target a narrow set of
+                        // product codes, add the patch list to the overall list.
+                        if (null != targetCodes)
+                        {
+                            if (!package.MspPackage.TargetUnspecified)
+                            {
+                                IEnumerable<WixBundlePatchTargetCodeRow> patchTargetCodes = targetCodesByPatch[package.MspPackage.ChainPackageId];
+
+                                targetCodes.AddRange(patchTargetCodes);
+                            }
+                            else // we have a patch that targets the world, so throw the whole list away.
+                            {
+                                targetCodes = null;
+                            }
+                        }
+                    }
+                    else if (WixBundlePackageType.Msu == package.Package.Type)
+                    {
+                        writer.WriteAttributeString("DetectCondition", package.MsuPackage.DetectCondition);
+                        writer.WriteAttributeString("KB", package.MsuPackage.MsuKB);
+                    }
+
+                    IEnumerable<WixBundleMsiFeatureRow> packageMsiFeatures = msiFeaturesByPackage[package.Package.WixChainItemId];
+
+                    foreach (WixBundleMsiFeatureRow feature in packageMsiFeatures)
+                    {
+                        writer.WriteStartElement("MsiFeature");
+                        writer.WriteAttributeString("Id", feature.Name);
+                        writer.WriteEndElement();
+                    }
+
+                    IEnumerable<WixBundleMsiPropertyRow> packageMsiProperties = msiPropertiesByPackage[package.Package.WixChainItemId];
+
+                    foreach (WixBundleMsiPropertyRow msiProperty in packageMsiProperties)
+                    {
+                        writer.WriteStartElement("MsiProperty");
+                        writer.WriteAttributeString("Id", msiProperty.Name);
+                        writer.WriteAttributeString("Value", msiProperty.Value);
+                        if (!String.IsNullOrEmpty(msiProperty.Condition))
+                        {
+                            writer.WriteAttributeString("Condition", msiProperty.Condition);
+                        }
+                        writer.WriteEndElement();
+                    }
+
+                    IEnumerable<WixBundleSlipstreamMspRow> packageSlipstreamMsps = slipstreamMspsByPackage[package.Package.WixChainItemId];
+
+                    foreach (WixBundleSlipstreamMspRow slipstreamMsp in packageSlipstreamMsps)
+                    {
+                        writer.WriteStartElement("SlipstreamMsp");
+                        writer.WriteAttributeString("Id", slipstreamMsp.MspPackageId);
+                        writer.WriteEndElement();
+                    }
+
+                    IEnumerable<WixBundlePackageExitCodeRow> packageExitCodes = exitCodesByPackage[package.Package.WixChainItemId];
+
+                    foreach (WixBundlePackageExitCodeRow exitCode in packageExitCodes)
+                    {
+                        writer.WriteStartElement("ExitCode");
+
+                        if (exitCode.Code.HasValue)
+                        {
+                            writer.WriteAttributeString("Code", unchecked((uint)exitCode.Code).ToString(CultureInfo.InvariantCulture));
+                        }
+                        else
+                        {
+                            writer.WriteAttributeString("Code", "*");
+                        }
+
+                        writer.WriteAttributeString("Type", ((int)exitCode.Behavior).ToString(CultureInfo.InvariantCulture));
+                        writer.WriteEndElement();
+                    }
+
+                    IEnumerable<WixBundlePackageCommandLineRow> packageCommandLines = commandLinesByPackage[package.Package.WixChainItemId];
+
+                    foreach (WixBundlePackageCommandLineRow commandLine in packageCommandLines)
+                    {
+                        writer.WriteStartElement("CommandLine");
+                        writer.WriteAttributeString("InstallArgument", commandLine.InstallArgument);
+                        writer.WriteAttributeString("UninstallArgument", commandLine.UninstallArgument);
+                        writer.WriteAttributeString("RepairArgument", commandLine.RepairArgument);
+                        writer.WriteAttributeString("Condition", commandLine.Condition);
+                        writer.WriteEndElement();
+                    }
+
+                    // Output the dependency information.
+                    foreach (ProvidesDependency dependency in package.Provides)
+                    {
+                        // TODO: Add to wixpdb as an imported table, or link package wixpdbs to bundle wixpdbs.
+                        dependency.WriteXml(writer);
+                    }
+
+                    IEnumerable<WixBundleRelatedPackageRow> packageRelatedPackages = relatedPackagesByPackage[package.Package.WixChainItemId];
+
+                    foreach (WixBundleRelatedPackageRow related in packageRelatedPackages)
+                    {
+                        writer.WriteStartElement("RelatedPackage");
+                        writer.WriteAttributeString("Id", related.Id);
+                        if (!String.IsNullOrEmpty(related.MinVersion))
+                        {
+                            writer.WriteAttributeString("MinVersion", related.MinVersion);
+                            writer.WriteAttributeString("MinInclusive", related.MinInclusive ? "yes" : "no");
+                        }
+                        if (!String.IsNullOrEmpty(related.MaxVersion))
+                        {
+                            writer.WriteAttributeString("MaxVersion", related.MaxVersion);
+                            writer.WriteAttributeString("MaxInclusive", related.MaxInclusive ? "yes" : "no");
+                        }
+                        writer.WriteAttributeString("OnlyDetect", related.OnlyDetect ? "yes" : "no");
+
+                        string[] relatedLanguages = related.Languages.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
+
+                        if (0 < relatedLanguages.Length)
+                        {
+                            writer.WriteAttributeString("LangInclusive", related.LangInclusive ? "yes" : "no");
+                            foreach (string language in relatedLanguages)
+                            {
+                                writer.WriteStartElement("Language");
+                                writer.WriteAttributeString("Id", language);
+                                writer.WriteEndElement();
+                            }
+                        }
+                        writer.WriteEndElement();
+                    }
+
+                    // Write any contained Payloads with the PackagePayload being first
+                    writer.WriteStartElement("PayloadRef");
+                    writer.WriteAttributeString("Id", package.Package.PackagePayload);
+                    writer.WriteEndElement();
+
+                    IEnumerable<WixBundlePayloadRow> packagePayloads = payloadsByPackage[package.Package.WixChainItemId];
+
+                    foreach (WixBundlePayloadRow payload in packagePayloads)
+                    {
+                        if (payload.Id != package.Package.PackagePayload)
+                        {
+                            writer.WriteStartElement("PayloadRef");
+                            writer.WriteAttributeString("Id", payload.Id);
+                            writer.WriteEndElement();
+                        }
+                    }
+
+                    writer.WriteEndElement(); // </XxxPackage>
+                }
+                writer.WriteEndElement(); // </Chain>
+
+                if (null != targetCodes)
+                {
+                    foreach (WixBundlePatchTargetCodeRow targetCode in targetCodes)
+                    {
+                        writer.WriteStartElement("PatchTargetCode");
+                        writer.WriteAttributeString("TargetCode", targetCode.TargetCode);
+                        writer.WriteAttributeString("Product", targetCode.TargetsProductCode ? "yes" : "no");
+                        writer.WriteEndElement();
+                    }
+                }
+
+                // Write the ApprovedExeForElevation elements.
+                IEnumerable<WixApprovedExeForElevationRow> approvedExesForElevation = this.Output.Tables["WixApprovedExeForElevation"].RowsAs<WixApprovedExeForElevationRow>();
+
+                foreach (WixApprovedExeForElevationRow approvedExeForElevation in approvedExesForElevation)
+                {
+                    writer.WriteStartElement("ApprovedExeForElevation");
+                    writer.WriteAttributeString("Id", approvedExeForElevation.Id);
+                    writer.WriteAttributeString("Key", approvedExeForElevation.Key);
+
+                    if (!String.IsNullOrEmpty(approvedExeForElevation.ValueName))
+                    {
+                        writer.WriteAttributeString("ValueName", approvedExeForElevation.ValueName);
+                    }
+
+                    if (approvedExeForElevation.Win64)
+                    {
+                        writer.WriteAttributeString("Win64", "yes");
+                    }
+
+                    writer.WriteEndElement();
+                }
+
+                writer.WriteEndDocument(); // </BurnManifest>
+            }
+        }
+
+        private void WriteBurnManifestContainerAttributes(XmlTextWriter writer, string executableName, WixBundleContainerRow container)
+        {
+            writer.WriteAttributeString("Id", container.Id);
+            writer.WriteAttributeString("FileSize", container.Size.ToString(CultureInfo.InvariantCulture));
+            writer.WriteAttributeString("Hash", container.Hash);
+
+            if (ContainerType.Detached == container.Type)
+            {
+                string resolvedUrl = this.ResolveUrl(container.DownloadUrl, null, null, container.Id, container.Name);
+                if (!String.IsNullOrEmpty(resolvedUrl))
+                {
+                    writer.WriteAttributeString("DownloadUrl", resolvedUrl);
+                }
+                else if (!String.IsNullOrEmpty(container.DownloadUrl))
+                {
+                    writer.WriteAttributeString("DownloadUrl", container.DownloadUrl);
+                }
+
+                writer.WriteAttributeString("FilePath", container.Name);
+            }
+            else if (ContainerType.Attached == container.Type)
+            {
+                if (!String.IsNullOrEmpty(container.DownloadUrl))
+                {
+                    Messaging.Instance.OnMessage(WixWarnings.DownloadUrlNotSupportedForAttachedContainers(container.SourceLineNumbers, container.Id));
+                }
+
+                writer.WriteAttributeString("FilePath", executableName); // attached containers use the name of the bundle since they are attached to the executable.
+                writer.WriteAttributeString("AttachedIndex", container.AttachedContainerIndex.ToString(CultureInfo.InvariantCulture));
+                writer.WriteAttributeString("Attached", "yes");
+                writer.WriteAttributeString("Primary", "yes");
+            }
+        }
+
+        private void WriteBurnManifestPayloadAttributes(XmlTextWriter writer, WixBundlePayloadRow payload, bool embeddedOnly, Dictionary<string, WixBundlePayloadRow> allPayloads)
+        {
+            Debug.Assert(!embeddedOnly || PackagingType.Embedded == payload.Packaging);
+
+            writer.WriteAttributeString("Id", payload.Id);
+            writer.WriteAttributeString("FilePath", payload.Name);
+            writer.WriteAttributeString("FileSize", payload.FileSize.ToString(CultureInfo.InvariantCulture));
+            writer.WriteAttributeString("Hash", payload.Hash);
+
+            if (payload.LayoutOnly)
+            {
+                writer.WriteAttributeString("LayoutOnly", "yes");
+            }
+
+            if (!String.IsNullOrEmpty(payload.PublicKey))
+            {
+                writer.WriteAttributeString("CertificateRootPublicKeyIdentifier", payload.PublicKey);
+            }
+
+            if (!String.IsNullOrEmpty(payload.Thumbprint))
+            {
+                writer.WriteAttributeString("CertificateRootThumbprint", payload.Thumbprint);
+            }
+
+            switch (payload.Packaging)
+            {
+                case PackagingType.Embedded: // this means it's in a container.
+                    if (!String.IsNullOrEmpty(payload.DownloadUrl))
+                    {
+                        Messaging.Instance.OnMessage(WixWarnings.DownloadUrlNotSupportedForEmbeddedPayloads(payload.SourceLineNumbers, payload.Id));
+                    }
+
+                    writer.WriteAttributeString("Packaging", "embedded");
+                    writer.WriteAttributeString("SourcePath", payload.EmbeddedId);
+
+                    if (Compiler.BurnUXContainerId != payload.Container)
+                    {
+                        writer.WriteAttributeString("Container", payload.Container);
+                    }
+                    break;
+
+                case PackagingType.External:
+                    string packageId = payload.ParentPackagePayload;
+                    string parentUrl = payload.ParentPackagePayload == null ? null : allPayloads[payload.ParentPackagePayload].DownloadUrl;
+                    string resolvedUrl = this.ResolveUrl(payload.DownloadUrl, parentUrl, packageId, payload.Id, payload.Name);
+                    if (!String.IsNullOrEmpty(resolvedUrl))
+                    {
+                        writer.WriteAttributeString("DownloadUrl", resolvedUrl);
+                    }
+                    else if (!String.IsNullOrEmpty(payload.DownloadUrl))
+                    {
+                        writer.WriteAttributeString("DownloadUrl", payload.DownloadUrl);
+                    }
+
+                    writer.WriteAttributeString("Packaging", "external");
+                    writer.WriteAttributeString("SourcePath", payload.Name);
+                    break;
+            }
+
+            if (!String.IsNullOrEmpty(payload.Catalog))
+            {
+                writer.WriteAttributeString("Catalog", payload.Catalog);
+            }
+        }
+
+        private string ResolveUrl(string url, string fallbackUrl, string packageId, string payloadId, string fileName)
+        {
+            string resolved = null;
+            foreach (IBinderFileManager fileManager in this.FileManagers)
+            {
+                resolved = fileManager.ResolveUrl(url, fallbackUrl, packageId, payloadId, fileName);
+                if (!String.IsNullOrEmpty(resolved))
+                {
+                    break;
+                }
+            }
+
+            return resolved;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/Bundles/CreateContainerCommand.cs b/src/WixToolset.Core/Bind/Bundles/CreateContainerCommand.cs
new file mode 100644
index 00000000..1bf987e3
--- /dev/null
+++ b/src/WixToolset.Core/Bind/Bundles/CreateContainerCommand.cs
@@ -0,0 +1,68 @@
+// 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.Bind.Bundles
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.IO;
+    using System.Linq;
+    using WixToolset.Cab;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+
+    /// <summary>
+    /// Creates cabinet files.
+    /// </summary>
+    internal class CreateContainerCommand : ICommand
+    {
+        public CompressionLevel DefaultCompressionLevel { private get; set; }
+
+        public IEnumerable<WixBundlePayloadRow> Payloads { private get; set; }
+
+        public string ManifestFile { private get; set; }
+
+        public string OutputPath { private get; set; }
+
+        public string Hash { get; private set; }
+
+        public long Size { get; private set; }
+
+        public void Execute()
+        {
+            int payloadCount = this.Payloads.Count(); // The number of embedded payloads
+
+            if (!String.IsNullOrEmpty(this.ManifestFile))
+            {
+                ++payloadCount;
+            }
+
+            using (WixCreateCab cab = new WixCreateCab(Path.GetFileName(this.OutputPath), Path.GetDirectoryName(this.OutputPath), payloadCount, 0, 0, this.DefaultCompressionLevel))
+            {
+                // If a manifest was provided always add it as "payload 0" to the container.
+                if (!String.IsNullOrEmpty(this.ManifestFile))
+                {
+                    cab.AddFile(this.ManifestFile, "0");
+                }
+
+                foreach (WixBundlePayloadRow payload in this.Payloads)
+                {
+                    Debug.Assert(PackagingType.Embedded == payload.Packaging);
+
+                    Messaging.Instance.OnMessage(WixVerboses.LoadingPayload(payload.FullFileName));
+
+                    cab.AddFile(payload.FullFileName, payload.EmbeddedId);
+                }
+
+                cab.Complete();
+            }
+
+            // Now that the container is created, set the outputs of the command.
+            FileInfo fileInfo = new FileInfo(this.OutputPath);
+
+            this.Hash = Common.GetFileHash(fileInfo.FullName);
+
+            this.Size = fileInfo.Length;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/Bundles/GetPackageFacadesCommand.cs b/src/WixToolset.Core/Bind/Bundles/GetPackageFacadesCommand.cs
new file mode 100644
index 00000000..dc19e380
--- /dev/null
+++ b/src/WixToolset.Core/Bind/Bundles/GetPackageFacadesCommand.cs
@@ -0,0 +1,62 @@
+// 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.Bind.Bundles
+{
+    using System.Collections.Generic;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+
+    internal class GetPackageFacadesCommand : ICommand
+    {
+        public Table PackageTable { private get; set; }
+
+        public Table ExePackageTable { private get; set; }
+
+        public Table MsiPackageTable { private get; set; }
+
+        public Table MspPackageTable { private get; set; }
+
+        public Table MsuPackageTable { private get; set; }
+
+        public IDictionary<string, PackageFacade> PackageFacades { get; private set; }
+
+        public void Execute()
+        {
+            RowDictionary<WixBundleExePackageRow> exePackages = new RowDictionary<WixBundleExePackageRow>(this.ExePackageTable);
+            RowDictionary<WixBundleMsiPackageRow> msiPackages = new RowDictionary<WixBundleMsiPackageRow>(this.MsiPackageTable);
+            RowDictionary<WixBundleMspPackageRow> mspPackages = new RowDictionary<WixBundleMspPackageRow>(this.MspPackageTable);
+            RowDictionary<WixBundleMsuPackageRow> msuPackages = new RowDictionary<WixBundleMsuPackageRow>(this.MsuPackageTable);
+
+            Dictionary<string, PackageFacade> facades = new Dictionary<string, PackageFacade>(this.PackageTable.Rows.Count);
+
+            foreach (WixBundlePackageRow package in this.PackageTable.Rows)
+            {
+                string id = package.WixChainItemId;
+                PackageFacade facade = null;
+
+                switch (package.Type)
+                {
+                    case WixBundlePackageType.Exe:
+                        facade = new PackageFacade(package, exePackages.Get(id));
+                        break;
+
+                    case WixBundlePackageType.Msi:
+                        facade = new PackageFacade(package, msiPackages.Get(id));
+                        break;
+
+                    case WixBundlePackageType.Msp:
+                        facade = new PackageFacade(package, mspPackages.Get(id));
+                        break;
+
+                    case WixBundlePackageType.Msu:
+                        facade = new PackageFacade(package, msuPackages.Get(id));
+                        break;
+                }
+
+                facades.Add(id, facade);
+            }
+
+            this.PackageFacades = facades;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/Bundles/OrderPackagesAndRollbackBoundariesCommand.cs b/src/WixToolset.Core/Bind/Bundles/OrderPackagesAndRollbackBoundariesCommand.cs
new file mode 100644
index 00000000..ac3a301d
--- /dev/null
+++ b/src/WixToolset.Core/Bind/Bundles/OrderPackagesAndRollbackBoundariesCommand.cs
@@ -0,0 +1,145 @@
+// 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.Bind.Bundles
+{
+    using System;
+    using System.Collections.Generic;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+
+    internal class OrderPackagesAndRollbackBoundariesCommand : ICommand
+    {
+        public Table WixGroupTable { private get; set; }
+
+        public RowDictionary<WixBundleRollbackBoundaryRow> Boundaries { private get; set; }
+
+        public IDictionary<string, PackageFacade> PackageFacades { private get; set; }
+
+        public IEnumerable<PackageFacade> OrderedPackageFacades { get; private set; }
+
+        public IEnumerable<WixBundleRollbackBoundaryRow> UsedRollbackBoundaries { get; private set; }
+
+        public void Execute()
+        {
+            List<PackageFacade> orderedFacades = new List<PackageFacade>();
+            List<WixBundleRollbackBoundaryRow> usedBoundaries = new List<WixBundleRollbackBoundaryRow>();
+
+            // Process the chain of packages to add them in the correct order
+            // and assign the forward rollback boundaries as appropriate. Remember
+            // rollback boundaries are authored as elements in the chain which
+            // we re-interpret here to add them as attributes on the next available
+            // package in the chain. Essentially we mark some packages as being
+            // the start of a rollback boundary when installing and repairing.
+            // We handle uninstall (aka: backwards) rollback boundaries after
+            // we get these install/repair (aka: forward) rollback boundaries
+            // defined.
+            WixBundleRollbackBoundaryRow previousRollbackBoundary = null;
+            WixBundleRollbackBoundaryRow lastRollbackBoundary = null;
+            bool boundaryHadX86Package = false;
+
+            foreach (WixGroupRow row in this.WixGroupTable.Rows)
+            {
+                if (ComplexReferenceChildType.Package == row.ChildType && ComplexReferenceParentType.PackageGroup == row.ParentType && "WixChain" == row.ParentId)
+                {
+                    PackageFacade facade = null;
+                    if (PackageFacades.TryGetValue(row.ChildId, out facade))
+                    {
+                        if (null != previousRollbackBoundary)
+                        {
+                            usedBoundaries.Add(previousRollbackBoundary);
+                            facade.Package.RollbackBoundary = previousRollbackBoundary.ChainPackageId;
+                            previousRollbackBoundary = null;
+
+                            boundaryHadX86Package = (facade.Package.x64 == YesNoType.Yes);
+                        }
+
+                        // Error if MSI transaction has x86 package preceding x64 packages
+                        if ((lastRollbackBoundary != null) && (lastRollbackBoundary.Transaction == YesNoType.Yes) 
+                            && boundaryHadX86Package 
+                            && (facade.Package.x64 == YesNoType.Yes))
+                        {
+                            Messaging.Instance.OnMessage(WixErrors.MsiTransactionX86BeforeX64(lastRollbackBoundary.SourceLineNumbers));
+                        }
+                        boundaryHadX86Package = boundaryHadX86Package || (facade.Package.x64 == YesNoType.No);
+
+                        orderedFacades.Add(facade);
+                    }
+                    else // must be a rollback boundary.
+                    {
+                        // Discard the next rollback boundary if we have a previously defined boundary.
+                        WixBundleRollbackBoundaryRow nextRollbackBoundary = Boundaries.Get(row.ChildId);
+                        if (null != previousRollbackBoundary)
+                        {
+                            Messaging.Instance.OnMessage(WixWarnings.DiscardedRollbackBoundary(nextRollbackBoundary.SourceLineNumbers, nextRollbackBoundary.ChainPackageId));
+                        }
+                        else
+                        {
+                            previousRollbackBoundary = nextRollbackBoundary;
+                            lastRollbackBoundary = nextRollbackBoundary;
+                        }
+                    }
+                }
+            }
+
+            if (null != previousRollbackBoundary)
+            {
+                Messaging.Instance.OnMessage(WixWarnings.DiscardedRollbackBoundary(previousRollbackBoundary.SourceLineNumbers, previousRollbackBoundary.ChainPackageId));
+            }
+
+            // With the forward rollback boundaries assigned, we can now go
+            // through the packages with rollback boundaries and assign backward
+            // rollback boundaries. Backward rollback boundaries are used when
+            // the chain is going "backwards" which (AFAIK) only happens during
+            // uninstall.
+            //
+            // Consider the scenario with three packages: A, B and C. Packages A
+            // and C are marked as rollback boundary packages and package B is
+            // not. The naive implementation would execute the chain like this
+            // (numbers indicate where rollback boundaries would end up):
+            //      install:    1 A B 2 C
+            //      uninstall:  2 C B 1 A
+            //
+            // The uninstall chain is wrong, A and B should be grouped together
+            // not C and B. The fix is to label packages with a "backwards"
+            // rollback boundary used during uninstall. The backwards rollback
+            // boundaries are assigned to the package *before* the next rollback
+            // boundary. Using our example from above again, I'll mark the
+            // backwards rollback boundaries prime (aka: with ').
+            //      install:    1 A B 1' 2 C 2'
+            //      uninstall:  2' C 2 1' B A 1
+            //
+            // If the marked boundaries are ignored during install you get the
+            // same thing as above (good) and if the non-marked boundaries are
+            // ignored during uninstall then A and B are correctly grouped.
+            // Here's what it looks like without all the markers:
+            //      install:    1 A B 2 C
+            //      uninstall:  2 C 1 B A
+            // Woot!
+            string previousRollbackBoundaryId = null;
+            PackageFacade previousFacade = null;
+
+            foreach (PackageFacade package in orderedFacades)
+            {
+                if (null != package.Package.RollbackBoundary)
+                {
+                    if (null != previousFacade)
+                    {
+                        previousFacade.Package.RollbackBoundaryBackward = previousRollbackBoundaryId;
+                    }
+
+                    previousRollbackBoundaryId = package.Package.RollbackBoundary;
+                }
+
+                previousFacade = package;
+            }
+
+            if (!String.IsNullOrEmpty(previousRollbackBoundaryId) && null != previousFacade)
+            {
+                previousFacade.Package.RollbackBoundaryBackward = previousRollbackBoundaryId;
+            }
+
+            this.OrderedPackageFacades = orderedFacades;
+            this.UsedRollbackBoundaries = usedBoundaries;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/Bundles/PackageFacade.cs b/src/WixToolset.Core/Bind/Bundles/PackageFacade.cs
new file mode 100644
index 00000000..f7e6410f
--- /dev/null
+++ b/src/WixToolset.Core/Bind/Bundles/PackageFacade.cs
@@ -0,0 +1,58 @@
+// 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.Bind.Bundles
+{
+    using WixToolset.Data.Rows;
+
+    internal class PackageFacade
+    {
+        private PackageFacade(WixBundlePackageRow package)
+        {
+            this.Package = package;
+            this.Provides = new ProvidesDependencyCollection();
+        }
+
+        public PackageFacade(WixBundlePackageRow package, WixBundleExePackageRow exePackage)
+            : this(package)
+        {
+            this.ExePackage = exePackage;
+        }
+
+        public PackageFacade(WixBundlePackageRow package, WixBundleMsiPackageRow msiPackage)
+            : this(package)
+        {
+            this.MsiPackage = msiPackage;
+        }
+
+        public PackageFacade(WixBundlePackageRow package, WixBundleMspPackageRow mspPackage)
+            : this(package)
+        {
+            this.MspPackage = mspPackage;
+        }
+
+        public PackageFacade(WixBundlePackageRow package, WixBundleMsuPackageRow msuPackage)
+            : this(package)
+        {
+            this.MsuPackage = msuPackage;
+        }
+
+        public WixBundlePackageRow Package { get; private set; }
+
+        public WixBundleExePackageRow ExePackage { get; private set; }
+
+        public WixBundleMsiPackageRow MsiPackage { get; private set; }
+
+        public WixBundleMspPackageRow MspPackage { get; private set; }
+
+        public WixBundleMsuPackageRow MsuPackage { get; private set; }
+
+        /// <summary>
+        /// The provides dependencies authored and imported for this package.
+        /// </summary>
+        /// <remarks>
+        /// TODO: Eventually this collection should turn into Rows so they are tracked in the PDB but
+        /// the relationship with the extension makes it much trickier to pull off.
+        /// </remarks>
+        public ProvidesDependencyCollection Provides { get; private set; }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/Bundles/ProcessExePackageCommand.cs b/src/WixToolset.Core/Bind/Bundles/ProcessExePackageCommand.cs
new file mode 100644
index 00000000..a1e7c271
--- /dev/null
+++ b/src/WixToolset.Core/Bind/Bundles/ProcessExePackageCommand.cs
@@ -0,0 +1,33 @@
+// 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.Bind.Bundles
+{
+    using System;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+
+    /// <summary>
+    /// Initializes package state from the Exe contents.
+    /// </summary>
+    internal class ProcessExePackageCommand : ICommand
+    {
+        public RowDictionary<WixBundlePayloadRow> AuthoredPayloads { private get; set; }
+
+        public PackageFacade Facade { private get; set; }
+
+        /// <summary>
+        /// Processes the Exe packages to add properties and payloads from the Exe packages.
+        /// </summary>
+        public void Execute()
+        {
+            WixBundlePayloadRow packagePayload = this.AuthoredPayloads.Get(this.Facade.Package.PackagePayload);
+
+            if (String.IsNullOrEmpty(this.Facade.Package.CacheId))
+            {
+                this.Facade.Package.CacheId = packagePayload.Hash;
+            }
+
+            this.Facade.Package.Version = packagePayload.Version;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/Bundles/ProcessMsiPackageCommand.cs b/src/WixToolset.Core/Bind/Bundles/ProcessMsiPackageCommand.cs
new file mode 100644
index 00000000..f73776c0
--- /dev/null
+++ b/src/WixToolset.Core/Bind/Bundles/ProcessMsiPackageCommand.cs
@@ -0,0 +1,560 @@
+// 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.Bind.Bundles
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Globalization;
+    using System.IO;
+    using System.Linq;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+    using WixToolset.Extensibility;
+    using WixToolset.Msi;
+    using WixToolset.Core.Native;
+    using Dtf = WixToolset.Dtf.WindowsInstaller;
+
+    /// <summary>
+    /// Initializes package state from the MSI contents.
+    /// </summary>
+    internal class ProcessMsiPackageCommand : ICommand
+    {
+        private const string PropertySqlFormat = "SELECT `Value` FROM `Property` WHERE `Property` = '{0}'";
+
+        public RowDictionary<WixBundlePayloadRow> AuthoredPayloads { private get; set; }
+
+        public PackageFacade Facade { private get; set; }
+
+        public IBinderFileManager FileManager { private get; set; }
+
+        public Table MsiFeatureTable { private get; set; }
+
+        public Table MsiPropertyTable { private get; set; }
+
+        public Table PayloadTable { private get; set; }
+
+        public Table RelatedPackageTable { private get; set; }
+
+        /// <summary>
+        /// Processes the MSI packages to add properties and payloads from the MSI packages.
+        /// </summary>
+        public void Execute()
+        {
+            WixBundlePayloadRow packagePayload = this.AuthoredPayloads.Get(this.Facade.Package.PackagePayload);
+
+            string sourcePath = packagePayload.FullFileName;
+            bool longNamesInImage = false;
+            bool compressed = false;
+            bool x64 = false;
+            try
+            {
+                // Read data out of the msi database...
+                using (Dtf.SummaryInfo sumInfo = new Dtf.SummaryInfo(sourcePath, false))
+                {
+                    // 1 is the Word Count summary information stream bit that means
+                    // the MSI uses short file names when set. We care about long file
+                    // names so check when the bit is not set.
+                    longNamesInImage = 0 == (sumInfo.WordCount & 1);
+
+                    // 2 is the Word Count summary information stream bit that means
+                    // files are compressed in the MSI by default when the bit is set.
+                    compressed = 2 == (sumInfo.WordCount & 2);
+
+                    x64 = (sumInfo.Template.Contains("x64") || sumInfo.Template.Contains("Intel64"));
+
+                    // 8 is the Word Count summary information stream bit that means
+                    // "Elevated privileges are not required to install this package."
+                    // in MSI 4.5 and below, if this bit is 0, elevation is required.
+                    this.Facade.Package.PerMachine = (0 == (sumInfo.WordCount & 8)) ? YesNoDefaultType.Yes : YesNoDefaultType.No;
+                    this.Facade.Package.x64 = x64 ? YesNoType.Yes : YesNoType.No;
+                }
+
+                using (Dtf.Database db = new Dtf.Database(sourcePath))
+                {
+                    this.Facade.MsiPackage.ProductCode = ProcessMsiPackageCommand.GetProperty(db, "ProductCode");
+                    this.Facade.MsiPackage.UpgradeCode = ProcessMsiPackageCommand.GetProperty(db, "UpgradeCode");
+                    this.Facade.MsiPackage.Manufacturer = ProcessMsiPackageCommand.GetProperty(db, "Manufacturer");
+                    this.Facade.MsiPackage.ProductLanguage = Convert.ToInt32(ProcessMsiPackageCommand.GetProperty(db, "ProductLanguage"), CultureInfo.InvariantCulture);
+                    this.Facade.MsiPackage.ProductVersion = ProcessMsiPackageCommand.GetProperty(db, "ProductVersion");
+
+                    if (!Common.IsValidModuleOrBundleVersion(this.Facade.MsiPackage.ProductVersion))
+                    {
+                        // not a proper .NET version (e.g., five fields); can we get a valid four-part version number?
+                        string version = null;
+                        string[] versionParts = this.Facade.MsiPackage.ProductVersion.Split('.');
+                        int count = versionParts.Length;
+                        if (0 < count)
+                        {
+                            version = versionParts[0];
+                            for (int i = 1; i < 4 && i < count; ++i)
+                            {
+                                version = String.Concat(version, ".", versionParts[i]);
+                            }
+                        }
+                        
+                        if (!String.IsNullOrEmpty(version) && Common.IsValidModuleOrBundleVersion(version))
+                        {
+                            Messaging.Instance.OnMessage(WixWarnings.VersionTruncated(this.Facade.Package.SourceLineNumbers, this.Facade.MsiPackage.ProductVersion, sourcePath, version));
+                            this.Facade.MsiPackage.ProductVersion = version;
+                        }
+                        else
+                        {
+                            Messaging.Instance.OnMessage(WixErrors.InvalidProductVersion(this.Facade.Package.SourceLineNumbers, this.Facade.MsiPackage.ProductVersion, sourcePath));
+                        }
+                    }
+
+                    if (String.IsNullOrEmpty(this.Facade.Package.CacheId))
+                    {
+                        this.Facade.Package.CacheId = String.Format("{0}v{1}", this.Facade.MsiPackage.ProductCode, this.Facade.MsiPackage.ProductVersion);
+                    }
+
+                    if (String.IsNullOrEmpty(this.Facade.Package.DisplayName))
+                    {
+                        this.Facade.Package.DisplayName = ProcessMsiPackageCommand.GetProperty(db, "ProductName");
+                    }
+
+                    if (String.IsNullOrEmpty(this.Facade.Package.Description))
+                    {
+                        this.Facade.Package.Description = ProcessMsiPackageCommand.GetProperty(db, "ARPCOMMENTS");
+                    }
+
+                    ISet<string> payloadNames = this.GetPayloadTargetNames();
+
+                    ISet<string> msiPropertyNames = this.GetMsiPropertyNames();
+
+                    this.SetPerMachineAppropriately(db, sourcePath);
+
+                    // Ensure the MSI package is appropriately marked visible or not.
+                    this.SetPackageVisibility(db, msiPropertyNames);
+
+                    // Unless the MSI or setup code overrides the default, set MSIFASTINSTALL for best performance.
+                    if (!msiPropertyNames.Contains("MSIFASTINSTALL") && !ProcessMsiPackageCommand.HasProperty(db, "MSIFASTINSTALL"))
+                    {
+                        this.AddMsiProperty("MSIFASTINSTALL", "7");
+                    }
+
+                    this.CreateRelatedPackages(db);
+
+                    // If feature selection is enabled, represent the Feature table in the manifest.
+                    if (this.Facade.MsiPackage.EnableFeatureSelection)
+                    {
+                        this.CreateMsiFeatures(db);
+                    }
+
+                    // Add all external cabinets as package payloads.
+                    this.ImportExternalCabinetAsPayloads(db, packagePayload, payloadNames);
+
+                    // Add all external files as package payloads and calculate the total install size as the rollup of
+                    // File table's sizes.
+                    this.Facade.Package.InstallSize = this.ImportExternalFileAsPayloadsAndReturnInstallSize(db, packagePayload, longNamesInImage, compressed, payloadNames);
+
+                    // Add all dependency providers from the MSI.
+                    this.ImportDependencyProviders(db);
+                }
+            }
+            catch (Dtf.InstallerException e)
+            {
+                Messaging.Instance.OnMessage(WixErrors.UnableToReadPackageInformation(this.Facade.Package.SourceLineNumbers, sourcePath, e.Message));
+            }
+        }
+
+        private ISet<string> GetPayloadTargetNames()
+        {
+            IEnumerable<string> payloadNames = this.PayloadTable.RowsAs<WixBundlePayloadRow>()
+                .Where(r => r.Package == this.Facade.Package.WixChainItemId)
+                .Select(r => r.Name);
+
+            return new HashSet<string>(payloadNames, StringComparer.OrdinalIgnoreCase);
+        }
+
+        private ISet<string> GetMsiPropertyNames()
+        {
+            IEnumerable<string> properties = this.MsiPropertyTable.RowsAs<WixBundleMsiPropertyRow>()
+                .Where(r => r.ChainPackageId == this.Facade.Package.WixChainItemId)
+                .Select(r => r.Name);
+
+            return new HashSet<string>(properties, StringComparer.Ordinal);
+        }
+
+        private void SetPerMachineAppropriately(Dtf.Database db, string sourcePath)
+        {
+            if (this.Facade.MsiPackage.ForcePerMachine)
+            {
+                if (YesNoDefaultType.No == this.Facade.Package.PerMachine)
+                {
+                    Messaging.Instance.OnMessage(WixWarnings.PerUserButForcingPerMachine(this.Facade.Package.SourceLineNumbers, sourcePath));
+                    this.Facade.Package.PerMachine = YesNoDefaultType.Yes; // ensure that we think the package is per-machine.
+                }
+
+                // Force ALLUSERS=1 via the MSI command-line.
+                this.AddMsiProperty("ALLUSERS", "1");
+            }
+            else
+            {
+                string allusers = ProcessMsiPackageCommand.GetProperty(db, "ALLUSERS");
+
+                if (String.IsNullOrEmpty(allusers))
+                {
+                    // Not forced per-machine and no ALLUSERS property, flip back to per-user.
+                    if (YesNoDefaultType.Yes == this.Facade.Package.PerMachine)
+                    {
+                        Messaging.Instance.OnMessage(WixWarnings.ImplicitlyPerUser(this.Facade.Package.SourceLineNumbers, sourcePath));
+                        this.Facade.Package.PerMachine = YesNoDefaultType.No;
+                    }
+                }
+                else if (allusers.Equals("1", StringComparison.Ordinal))
+                {
+                    if (YesNoDefaultType.No == this.Facade.Package.PerMachine)
+                    {
+                        Messaging.Instance.OnMessage(WixErrors.PerUserButAllUsersEquals1(this.Facade.Package.SourceLineNumbers, sourcePath));
+                    }
+                }
+                else if (allusers.Equals("2", StringComparison.Ordinal))
+                {
+                    Messaging.Instance.OnMessage(WixWarnings.DiscouragedAllUsersValue(this.Facade.Package.SourceLineNumbers, sourcePath, (YesNoDefaultType.Yes == this.Facade.Package.PerMachine) ? "machine" : "user"));
+                }
+                else
+                {
+                    Messaging.Instance.OnMessage(WixErrors.UnsupportedAllUsersValue(this.Facade.Package.SourceLineNumbers, sourcePath, allusers));
+                }
+            }
+        }
+
+        private void SetPackageVisibility(Dtf.Database db, ISet<string> msiPropertyNames)
+        {
+            bool alreadyVisible = !ProcessMsiPackageCommand.HasProperty(db, "ARPSYSTEMCOMPONENT");
+
+            if (alreadyVisible != this.Facade.Package.Visible) // if not already set to the correct visibility.
+            {
+                // If the authoring specifically added "ARPSYSTEMCOMPONENT", don't do it again.
+                if (!msiPropertyNames.Contains("ARPSYSTEMCOMPONENT"))
+                {
+                    this.AddMsiProperty("ARPSYSTEMCOMPONENT", this.Facade.Package.Visible ? String.Empty : "1");
+                }
+            }
+        }
+
+        private void CreateRelatedPackages(Dtf.Database db)
+        {
+            // Represent the Upgrade table as related packages.
+            if (db.Tables.Contains("Upgrade"))
+            {
+                using (Dtf.View view = db.OpenView("SELECT `UpgradeCode`, `VersionMin`, `VersionMax`, `Language`, `Attributes` FROM `Upgrade`"))
+                {
+                    view.Execute();
+                    while (true)
+                    {
+                        using (Dtf.Record record = view.Fetch())
+                        {
+                            if (null == record)
+                            {
+                                break;
+                            }
+
+                            WixBundleRelatedPackageRow related = (WixBundleRelatedPackageRow)this.RelatedPackageTable.CreateRow(this.Facade.Package.SourceLineNumbers);
+                            related.ChainPackageId = this.Facade.Package.WixChainItemId;
+                            related.Id = record.GetString(1);
+                            related.MinVersion = record.GetString(2);
+                            related.MaxVersion = record.GetString(3);
+                            related.Languages = record.GetString(4);
+
+                            int attributes = record.GetInteger(5);
+                            related.OnlyDetect = (attributes & MsiInterop.MsidbUpgradeAttributesOnlyDetect) == MsiInterop.MsidbUpgradeAttributesOnlyDetect;
+                            related.MinInclusive = (attributes & MsiInterop.MsidbUpgradeAttributesVersionMinInclusive) == MsiInterop.MsidbUpgradeAttributesVersionMinInclusive;
+                            related.MaxInclusive = (attributes & MsiInterop.MsidbUpgradeAttributesVersionMaxInclusive) == MsiInterop.MsidbUpgradeAttributesVersionMaxInclusive;
+                            related.LangInclusive = (attributes & MsiInterop.MsidbUpgradeAttributesLanguagesExclusive) == 0;
+                        }
+                    }
+                }
+            }
+        }
+
+        private void CreateMsiFeatures(Dtf.Database db)
+        {
+            if (db.Tables.Contains("Feature"))
+            {
+                using (Dtf.View featureView = db.OpenView("SELECT `Component_` FROM `FeatureComponents` WHERE `Feature_` = ?"))
+                using (Dtf.View componentView = db.OpenView("SELECT `FileSize` FROM `File` WHERE `Component_` = ?"))
+                {
+                    using (Dtf.Record featureRecord = new Dtf.Record(1))
+                    using (Dtf.Record componentRecord = new Dtf.Record(1))
+                    {
+                        using (Dtf.View allFeaturesView = db.OpenView("SELECT * FROM `Feature`"))
+                        {
+                            allFeaturesView.Execute();
+
+                            while (true)
+                            {
+                                using (Dtf.Record allFeaturesResultRecord = allFeaturesView.Fetch())
+                                {
+                                    if (null == allFeaturesResultRecord)
+                                    {
+                                        break;
+                                    }
+
+                                    string featureName = allFeaturesResultRecord.GetString(1);
+
+                                    // Calculate the Feature size.
+                                    featureRecord.SetString(1, featureName);
+                                    featureView.Execute(featureRecord);
+
+                                    // Loop over all the components for the feature to calculate the size of the feature.
+                                    long size = 0;
+                                    while (true)
+                                    {
+                                        using (Dtf.Record componentResultRecord = featureView.Fetch())
+                                        {
+                                            if (null == componentResultRecord)
+                                            {
+                                                break;
+                                            }
+                                            string component = componentResultRecord.GetString(1);
+                                            componentRecord.SetString(1, component);
+                                            componentView.Execute(componentRecord);
+
+                                            while (true)
+                                            {
+                                                using (Dtf.Record fileResultRecord = componentView.Fetch())
+                                                {
+                                                    if (null == fileResultRecord)
+                                                    {
+                                                        break;
+                                                    }
+
+                                                    string fileSize = fileResultRecord.GetString(1);
+                                                    size += Convert.ToInt32(fileSize, CultureInfo.InvariantCulture.NumberFormat);
+                                                }
+                                            }
+                                        }
+                                    }
+
+                                    WixBundleMsiFeatureRow feature = (WixBundleMsiFeatureRow)this.MsiFeatureTable.CreateRow(this.Facade.Package.SourceLineNumbers);
+                                    feature.ChainPackageId = this.Facade.Package.WixChainItemId;
+                                    feature.Name = featureName;
+                                    feature.Parent = allFeaturesResultRecord.GetString(2);
+                                    feature.Title = allFeaturesResultRecord.GetString(3);
+                                    feature.Description = allFeaturesResultRecord.GetString(4);
+                                    feature.Display = allFeaturesResultRecord.GetInteger(5);
+                                    feature.Level = allFeaturesResultRecord.GetInteger(6);
+                                    feature.Directory = allFeaturesResultRecord.GetString(7);
+                                    feature.Attributes = allFeaturesResultRecord.GetInteger(8);
+                                    feature.Size = size;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        private void ImportExternalCabinetAsPayloads(Dtf.Database db, WixBundlePayloadRow packagePayload, ISet<string> payloadNames)
+        {
+            if (db.Tables.Contains("Media"))
+            {
+                foreach (string cabinet in db.ExecuteStringQuery("SELECT `Cabinet` FROM `Media`"))
+                {
+                    if (!String.IsNullOrEmpty(cabinet) && !cabinet.StartsWith("#", StringComparison.Ordinal))
+                    {
+                        // If we didn't find the Payload as an existing child of the package, we need to
+                        // add it.  We expect the file to exist on-disk in the same relative location as
+                        // the MSI expects to find it...
+                        string cabinetName = Path.Combine(Path.GetDirectoryName(packagePayload.Name), cabinet);
+
+                        if (!payloadNames.Contains(cabinetName))
+                        {
+                            string generatedId = Common.GenerateIdentifier("cab", packagePayload.Id, cabinet);
+                            string payloadSourceFile = FileManager.ResolveRelatedFile(packagePayload.UnresolvedSourceFile, cabinet, "Cabinet", this.Facade.Package.SourceLineNumbers, BindStage.Normal);
+
+                            WixBundlePayloadRow payload = (WixBundlePayloadRow)this.PayloadTable.CreateRow(this.Facade.Package.SourceLineNumbers);
+                            payload.Id = generatedId;
+                            payload.Name = cabinetName;
+                            payload.SourceFile = payloadSourceFile;
+                            payload.Compressed = packagePayload.Compressed;
+                            payload.UnresolvedSourceFile = cabinetName;
+                            payload.Package = packagePayload.Package;
+                            payload.Container = packagePayload.Container;
+                            payload.ContentFile = true;
+                            payload.EnableSignatureValidation = packagePayload.EnableSignatureValidation;
+                            payload.Packaging = packagePayload.Packaging;
+                            payload.ParentPackagePayload = packagePayload.Id;
+                        }
+                    }
+                }
+            }
+        }
+
+        private long ImportExternalFileAsPayloadsAndReturnInstallSize(Dtf.Database db, WixBundlePayloadRow packagePayload, bool longNamesInImage, bool compressed, ISet<string> payloadNames)
+        {
+            long size = 0;
+
+            if (db.Tables.Contains("Component") && db.Tables.Contains("Directory") && db.Tables.Contains("File"))
+            {
+                Hashtable directories = new Hashtable();
+
+                // Load up the directory hash table so we will be able to resolve source paths
+                // for files in the MSI database.
+                using (Dtf.View view = db.OpenView("SELECT `Directory`, `Directory_Parent`, `DefaultDir` FROM `Directory`"))
+                {
+                    view.Execute();
+                    while (true)
+                    {
+                        using (Dtf.Record record = view.Fetch())
+                        {
+                            if (null == record)
+                            {
+                                break;
+                            }
+
+                            string sourceName = Installer.GetName(record.GetString(3), true, longNamesInImage);
+                            directories.Add(record.GetString(1), new ResolvedDirectory(record.GetString(2), sourceName));
+                        }
+                    }
+                }
+
+                // Resolve the source paths to external files and add each file size to the total
+                // install size of the package.
+                using (Dtf.View view = db.OpenView("SELECT `Directory_`, `File`, `FileName`, `File`.`Attributes`, `FileSize` FROM `Component`, `File` WHERE `Component`.`Component`=`File`.`Component_`"))
+                {
+                    view.Execute();
+                    while (true)
+                    {
+                        using (Dtf.Record record = view.Fetch())
+                        {
+                            if (null == record)
+                            {
+                                break;
+                            }
+
+                            // Skip adding the loose files as payloads if it was suppressed.
+                            if (!this.Facade.MsiPackage.SuppressLooseFilePayloadGeneration)
+                            {
+                                // If the file is explicitly uncompressed or the MSI is uncompressed and the file is not
+                                // explicitly marked compressed then this is an external file.
+                                if (MsiInterop.MsidbFileAttributesNoncompressed == (record.GetInteger(4) & MsiInterop.MsidbFileAttributesNoncompressed) ||
+                                    (!compressed && 0 == (record.GetInteger(4) & MsiInterop.MsidbFileAttributesCompressed)))
+                                {
+                                    string fileSourcePath = Binder.GetFileSourcePath(directories, record.GetString(1), record.GetString(3), compressed, longNamesInImage);
+                                    string name = Path.Combine(Path.GetDirectoryName(packagePayload.Name), fileSourcePath);
+
+                                    if (!payloadNames.Contains(name))
+                                    {
+                                        string generatedId = Common.GenerateIdentifier("f", packagePayload.Id, record.GetString(2));
+                                        string payloadSourceFile = FileManager.ResolveRelatedFile(packagePayload.UnresolvedSourceFile, fileSourcePath, "File", this.Facade.Package.SourceLineNumbers, BindStage.Normal);
+
+                                        WixBundlePayloadRow payload = (WixBundlePayloadRow)this.PayloadTable.CreateRow(this.Facade.Package.SourceLineNumbers);
+                                        payload.Id = generatedId;
+                                        payload.Name = name;
+                                        payload.SourceFile = payloadSourceFile;
+                                        payload.Compressed = packagePayload.Compressed;
+                                        payload.UnresolvedSourceFile = name;
+                                        payload.Package = packagePayload.Package;
+                                        payload.Container = packagePayload.Container;
+                                        payload.ContentFile = true;
+                                        payload.EnableSignatureValidation = packagePayload.EnableSignatureValidation;
+                                        payload.Packaging = packagePayload.Packaging;
+                                        payload.ParentPackagePayload = packagePayload.Id;
+                                    }
+                                }
+                            }
+
+                            size += record.GetInteger(5);
+                        }
+                    }
+                }
+            }
+
+            return size;
+        }
+
+        private void AddMsiProperty(string name, string value)
+        {
+            WixBundleMsiPropertyRow row = (WixBundleMsiPropertyRow)this.MsiPropertyTable.CreateRow(this.Facade.MsiPackage.SourceLineNumbers);
+            row.ChainPackageId = this.Facade.Package.WixChainItemId;
+            row.Name = name;
+            row.Value = value;
+        }
+
+        private void ImportDependencyProviders(Dtf.Database db)
+        {
+            if (db.Tables.Contains("WixDependencyProvider"))
+            {
+                string query = "SELECT `ProviderKey`, `Version`, `DisplayName`, `Attributes` FROM `WixDependencyProvider`";
+
+                using (Dtf.View view = db.OpenView(query))
+                {
+                    view.Execute();
+                    while (true)
+                    {
+                        using (Dtf.Record record = view.Fetch())
+                        {
+                            if (null == record)
+                            {
+                                break;
+                            }
+
+                            // Import the provider key and attributes.
+                            string providerKey = record.GetString(1);
+                            string version = record.GetString(2) ?? this.Facade.MsiPackage.ProductVersion;
+                            string displayName = record.GetString(3) ?? this.Facade.Package.DisplayName;
+                            int attributes = record.GetInteger(4);
+
+                            ProvidesDependency dependency = new ProvidesDependency(providerKey, version, displayName, attributes);
+                            dependency.Imported = true;
+
+                            this.Facade.Provides.Add(dependency);
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Queries a Windows Installer database for a Property value.
+        /// </summary>
+        /// <param name="db">Database to query.</param>
+        /// <param name="property">Property to examine.</param>
+        /// <returns>String value for result or null if query doesn't match a single result.</returns>
+        private static string GetProperty(Dtf.Database db, string property)
+        {
+            try
+            {
+                return db.ExecuteScalar(PropertyQuery(property)).ToString();
+            }
+            catch (Dtf.InstallerException)
+            {
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Queries a Windows Installer database to determine if one or more rows exist in the Property table.
+        /// </summary>
+        /// <param name="db">Database to query.</param>
+        /// <param name="property">Property to examine.</param>
+        /// <returns>True if query matches at least one result.</returns>
+        private static bool HasProperty(Dtf.Database db, string property)
+        {
+            try
+            {
+                return 0 < db.ExecuteQuery(PropertyQuery(property)).Count;
+            }
+            catch (Dtf.InstallerException)
+            {
+            }
+
+            return false;
+        }
+
+        private static string PropertyQuery(string property)
+        {
+            // quick sanity check that we'll be creating a valid query...
+            // TODO: Are there any other special characters we should be looking for?
+            Debug.Assert(!property.Contains("'"));
+
+            return String.Format(CultureInfo.InvariantCulture, ProcessMsiPackageCommand.PropertySqlFormat, property);
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/Bundles/ProcessMspPackageCommand.cs b/src/WixToolset.Core/Bind/Bundles/ProcessMspPackageCommand.cs
new file mode 100644
index 00000000..24063221
--- /dev/null
+++ b/src/WixToolset.Core/Bind/Bundles/ProcessMspPackageCommand.cs
@@ -0,0 +1,189 @@
+// 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.Bind.Bundles
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Globalization;
+    using System.IO;
+    using System.Text;
+    using System.Xml;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+    using Dtf = WixToolset.Dtf.WindowsInstaller;
+
+    /// <summary>
+    /// Initializes package state from the Msp contents.
+    /// </summary>
+    internal class ProcessMspPackageCommand : ICommand
+    {
+        private const string PatchMetadataFormat = "SELECT `Value` FROM `MsiPatchMetadata` WHERE `Property` = '{0}'";
+        private static readonly Encoding XmlOutputEncoding = new UTF8Encoding(false);
+
+        public RowDictionary<WixBundlePayloadRow> AuthoredPayloads { private get; set; }
+
+        public PackageFacade Facade { private get; set; }
+
+        public Table WixBundlePatchTargetCodeTable { private get; set; }
+
+        /// <summary>
+        /// Processes the Msp packages to add properties and payloads from the Msp packages.
+        /// </summary>
+        public void Execute()
+        {
+            WixBundlePayloadRow packagePayload = this.AuthoredPayloads.Get(this.Facade.Package.PackagePayload);
+
+            string sourcePath = packagePayload.FullFileName;
+
+            try
+            {
+                // Read data out of the msp database...
+                using (Dtf.SummaryInfo sumInfo = new Dtf.SummaryInfo(sourcePath, false))
+                {
+                    this.Facade.MspPackage.PatchCode = sumInfo.RevisionNumber.Substring(0, 38);
+                }
+
+                using (Dtf.Database db = new Dtf.Database(sourcePath))
+                {
+                    if (String.IsNullOrEmpty(this.Facade.Package.DisplayName))
+                    {
+                        this.Facade.Package.DisplayName = ProcessMspPackageCommand.GetPatchMetadataProperty(db, "DisplayName");
+                    }
+
+                    if (String.IsNullOrEmpty(this.Facade.Package.Description))
+                    {
+                        this.Facade.Package.Description = ProcessMspPackageCommand.GetPatchMetadataProperty(db, "Description");
+                    }
+
+                    this.Facade.MspPackage.Manufacturer = ProcessMspPackageCommand.GetPatchMetadataProperty(db, "ManufacturerName");
+                }
+
+                this.ProcessPatchXml(packagePayload, sourcePath);
+            }
+            catch (Dtf.InstallerException e)
+            {
+                Messaging.Instance.OnMessage(WixErrors.UnableToReadPackageInformation(packagePayload.SourceLineNumbers, sourcePath, e.Message));
+                return;
+            }
+
+            if (String.IsNullOrEmpty(this.Facade.Package.CacheId))
+            {
+                this.Facade.Package.CacheId = this.Facade.MspPackage.PatchCode;
+            }
+        }
+
+        private void ProcessPatchXml(WixBundlePayloadRow packagePayload, string sourcePath)
+        {
+            HashSet<string> uniqueTargetCodes = new HashSet<string>();
+
+            string patchXml = Dtf.Installer.ExtractPatchXmlData(sourcePath);
+
+            XmlDocument doc = new XmlDocument();
+            doc.LoadXml(patchXml);
+
+            XmlNamespaceManager nsmgr = new XmlNamespaceManager(doc.NameTable);
+            nsmgr.AddNamespace("p", "http://www.microsoft.com/msi/patch_applicability.xsd");
+
+            // Determine target ProductCodes and/or UpgradeCodes.
+            foreach (XmlNode node in doc.SelectNodes("/p:MsiPatch/p:TargetProduct", nsmgr))
+            {
+                // If this patch targets a product code, this is the best case.
+                XmlNode targetCodeElement = node.SelectSingleNode("p:TargetProductCode", nsmgr);
+                WixBundlePatchTargetCodeAttributes attributes = WixBundlePatchTargetCodeAttributes.None;
+
+                if (ProcessMspPackageCommand.TargetsCode(targetCodeElement))
+                {
+                    attributes = WixBundlePatchTargetCodeAttributes.TargetsProductCode;
+                }
+                else // maybe targets an upgrade code?
+                {
+                    targetCodeElement = node.SelectSingleNode("p:UpgradeCode", nsmgr);
+                    if (ProcessMspPackageCommand.TargetsCode(targetCodeElement))
+                    {
+                        attributes = WixBundlePatchTargetCodeAttributes.TargetsUpgradeCode;
+                    }
+                    else // this patch targets an unknown number of products
+                    {
+                        this.Facade.MspPackage.Attributes |= WixBundleMspPackageAttributes.TargetUnspecified;
+                    }
+                }
+
+                string targetCode = targetCodeElement.InnerText;
+
+                if (uniqueTargetCodes.Add(targetCode))
+                {
+                    WixBundlePatchTargetCodeRow row = (WixBundlePatchTargetCodeRow)this.WixBundlePatchTargetCodeTable.CreateRow(packagePayload.SourceLineNumbers);
+                    row.MspPackageId = packagePayload.Id;
+                    row.TargetCode = targetCode;
+                    row.Attributes = attributes;
+                }
+            }
+
+            // Suppress patch sequence data for improved performance.
+            XmlNode root = doc.DocumentElement;
+            foreach (XmlNode node in root.SelectNodes("p:SequenceData", nsmgr))
+            {
+                root.RemoveChild(node);
+            }
+
+            // Save the XML as compact as possible.
+            using (StringWriter writer = new StringWriter())
+            {
+                XmlWriterSettings settings = new XmlWriterSettings()
+                {
+                    Encoding = ProcessMspPackageCommand.XmlOutputEncoding,
+                    Indent = false,
+                    NewLineChars = string.Empty,
+                    NewLineHandling = NewLineHandling.Replace,
+                };
+
+                using (XmlWriter xmlWriter = XmlWriter.Create(writer, settings))
+                {
+                    doc.WriteTo(xmlWriter);
+                }
+
+                this.Facade.MspPackage.PatchXml = writer.ToString();
+            }
+        }
+
+        /// <summary>
+        /// Queries a Windows Installer patch database for a Property value from the MsiPatchMetadata table.
+        /// </summary>
+        /// <param name="db">Database to query.</param>
+        /// <param name="property">Property to examine.</param>
+        /// <returns>String value for result or null if query doesn't match a single result.</returns>
+        private static string GetPatchMetadataProperty(Dtf.Database db, string property)
+        {
+            try
+            {
+                return db.ExecuteScalar(PatchMetadataPropertyQuery(property)).ToString();
+            }
+            catch (Dtf.InstallerException)
+            {
+            }
+
+            return null;
+        }
+
+        private static string PatchMetadataPropertyQuery(string property)
+        {
+            // quick sanity check that we'll be creating a valid query...
+            // TODO: Are there any other special characters we should be looking for?
+            Debug.Assert(!property.Contains("'"));
+
+            return String.Format(CultureInfo.InvariantCulture, ProcessMspPackageCommand.PatchMetadataFormat, property);
+        }
+
+        private static bool TargetsCode(XmlNode node)
+        {
+            if (null != node)
+            {
+                XmlAttribute attr = node.Attributes["Validate"];
+                return null != attr && "true".Equals(attr.Value);
+            }
+
+            return false;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/Bundles/ProcessMsuPackageCommand.cs b/src/WixToolset.Core/Bind/Bundles/ProcessMsuPackageCommand.cs
new file mode 100644
index 00000000..ba59f5f5
--- /dev/null
+++ b/src/WixToolset.Core/Bind/Bundles/ProcessMsuPackageCommand.cs
@@ -0,0 +1,30 @@
+// 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.Bind.Bundles
+{
+    using System;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+
+    /// <summary>
+    /// Processes the Msu packages to add properties and payloads from the Msu packages.
+    /// </summary>
+    internal class ProcessMsuPackageCommand : ICommand
+    {
+        public RowDictionary<WixBundlePayloadRow> AuthoredPayloads { private get; set; }
+
+        public PackageFacade Facade { private get; set; }
+
+        public void Execute()
+        {
+            WixBundlePayloadRow packagePayload = this.AuthoredPayloads.Get(this.Facade.Package.PackagePayload);
+
+            if (String.IsNullOrEmpty(this.Facade.Package.CacheId))
+            {
+                this.Facade.Package.CacheId = packagePayload.Hash;
+            }
+
+            this.Facade.Package.PerMachine = YesNoDefaultType.Yes; // MSUs are always per-machine.
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/Bundles/ProcessPayloadsCommand.cs b/src/WixToolset.Core/Bind/Bundles/ProcessPayloadsCommand.cs
new file mode 100644
index 00000000..a83a7a4a
--- /dev/null
+++ b/src/WixToolset.Core/Bind/Bundles/ProcessPayloadsCommand.cs
@@ -0,0 +1,159 @@
+// 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.Bind.Bundles
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.IO;
+    using System.Security.Cryptography;
+    using System.Security.Cryptography.X509Certificates;
+    using System.Text;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+
+    internal class ProcessPayloadsCommand : ICommand
+    {
+        private static readonly Version EmptyVersion = new Version(0, 0, 0, 0);
+
+        public IEnumerable<WixBundlePayloadRow> Payloads { private get; set; }
+
+        public PackagingType DefaultPackaging { private get; set; }
+
+        public string LayoutDirectory { private get; set; }
+
+        public IEnumerable<FileTransfer> FileTransfers { get; private set; }
+
+        public void Execute()
+        {
+            List<FileTransfer> fileTransfers = new List<FileTransfer>();
+
+            foreach (WixBundlePayloadRow payload in this.Payloads)
+            {
+                string normalizedPath = payload.Name.Replace('\\', '/');
+                if (normalizedPath.StartsWith("../", StringComparison.Ordinal) || normalizedPath.Contains("/../"))
+                {
+                    Messaging.Instance.OnMessage(WixErrors.PayloadMustBeRelativeToCache(payload.SourceLineNumbers, "Payload", "Name", payload.Name));
+                }
+
+                // Embedded files (aka: files from binary .wixlibs) are not content files (because they are hidden
+                // in the .wixlib).
+                ObjectField field = (ObjectField)payload.Fields[2];
+                payload.ContentFile = !field.EmbeddedFileIndex.HasValue;
+
+                this.UpdatePayloadPackagingType(payload);
+
+                if (String.IsNullOrEmpty(payload.SourceFile))
+                {
+                    // Remote payloads obviously cannot be embedded.
+                    Debug.Assert(PackagingType.Embedded != payload.Packaging);
+                }
+                else // not a remote payload so we have a lot more to update.
+                {
+                    this.UpdatePayloadFileInformation(payload);
+
+                    this.UpdatePayloadVersionInformation(payload);
+
+                    // External payloads need to be transfered.
+                    if (PackagingType.External == payload.Packaging)
+                    {
+                        FileTransfer transfer;
+                        if (FileTransfer.TryCreate(payload.FullFileName, Path.Combine(this.LayoutDirectory, payload.Name), false, "Payload", payload.SourceLineNumbers, out transfer))
+                        {
+                            fileTransfers.Add(transfer);
+                        }
+                    }
+                }
+            }
+
+            this.FileTransfers = fileTransfers;
+        }
+
+        private void UpdatePayloadPackagingType(WixBundlePayloadRow payload)
+        {
+            if (PackagingType.Unknown == payload.Packaging)
+            {
+                if (YesNoDefaultType.Yes == payload.Compressed)
+                {
+                    payload.Packaging = PackagingType.Embedded;
+                }
+                else if (YesNoDefaultType.No == payload.Compressed)
+                {
+                    payload.Packaging = PackagingType.External;
+                }
+                else
+                {
+                    payload.Packaging = this.DefaultPackaging;
+                }
+            }
+
+            // Embedded payloads that are not assigned a container already are placed in the default attached
+            // container.
+            if (PackagingType.Embedded == payload.Packaging && String.IsNullOrEmpty(payload.Container))
+            {
+                payload.Container = Compiler.BurnDefaultAttachedContainerId;
+            }
+        }
+
+        private void UpdatePayloadFileInformation(WixBundlePayloadRow payload)
+        {
+            FileInfo fileInfo = new FileInfo(payload.SourceFile);
+
+            if (null != fileInfo)
+            {
+                payload.FileSize = (int)fileInfo.Length;
+
+                payload.Hash = Common.GetFileHash(fileInfo.FullName);
+
+                // Try to get the certificate if the payload is a signed file and we're not suppressing signature validation.
+                if (payload.EnableSignatureValidation)
+                {
+                    X509Certificate2 certificate = null;
+                    try
+                    {
+                        certificate = new X509Certificate2(fileInfo.FullName);
+                    }
+                    catch (CryptographicException) // we don't care about non-signed files.
+                    {
+                    }
+
+                    // If there is a certificate, remember its hashed public key identifier and thumbprint.
+                    if (null != certificate)
+                    {
+                        byte[] publicKeyIdentifierHash = new byte[128];
+                        uint publicKeyIdentifierHashSize = (uint)publicKeyIdentifierHash.Length;
+
+                        WixToolset.Core.Native.NativeMethods.HashPublicKeyInfo(certificate.Handle, publicKeyIdentifierHash, ref publicKeyIdentifierHashSize);
+                        StringBuilder sb = new StringBuilder(((int)publicKeyIdentifierHashSize + 1) * 2);
+                        for (int i = 0; i < publicKeyIdentifierHashSize; ++i)
+                        {
+                            sb.AppendFormat("{0:X2}", publicKeyIdentifierHash[i]);
+                        }
+
+                        payload.PublicKey = sb.ToString();
+                        payload.Thumbprint = certificate.Thumbprint;
+                    }
+                }
+            }
+        }
+
+        private void UpdatePayloadVersionInformation(WixBundlePayloadRow payload)
+        {
+            FileVersionInfo versionInfo = FileVersionInfo.GetVersionInfo(payload.SourceFile);
+
+            if (null != versionInfo)
+            {
+                // Use the fixed version info block for the file since the resource text may not be a dotted quad.
+                Version version = new Version(versionInfo.ProductMajorPart, versionInfo.ProductMinorPart, versionInfo.ProductBuildPart, versionInfo.ProductPrivatePart);
+
+                if (ProcessPayloadsCommand.EmptyVersion != version)
+                {
+                    payload.Version = version.ToString();
+                }
+
+                payload.Description = versionInfo.FileDescription;
+                payload.DisplayName = versionInfo.ProductName;
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/Bundles/VerifyPayloadsWithCatalogCommand.cs b/src/WixToolset.Core/Bind/Bundles/VerifyPayloadsWithCatalogCommand.cs
new file mode 100644
index 00000000..9c614c26
--- /dev/null
+++ b/src/WixToolset.Core/Bind/Bundles/VerifyPayloadsWithCatalogCommand.cs
@@ -0,0 +1,148 @@
+// 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.Bind.Bundles
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Linq;
+    using System.Runtime.InteropServices;
+    using System.Text;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+
+    internal class VerifyPayloadsWithCatalogCommand : ICommand
+    {
+        public IEnumerable<WixBundleCatalogRow> Catalogs { private get; set; }
+
+        public IEnumerable<WixBundlePayloadRow> Payloads { private get; set; }
+
+        public void Execute()
+        {
+            List<CatalogIdWithPath> catalogIdsWithPaths = this.Catalogs
+                .Join(this.Payloads,
+                    catalog => catalog.Payload,
+                    payload => payload.Id,
+                    (catalog, payload) => new CatalogIdWithPath() { Id = catalog.Id, FullPath = Path.GetFullPath(payload.SourceFile) })
+                .ToList();
+
+            foreach (WixBundlePayloadRow payloadInfo in this.Payloads)
+            {
+                // Payloads that are not embedded should be verfied.
+                if (String.IsNullOrEmpty(payloadInfo.EmbeddedId))
+                {
+                    bool validated = false;
+
+                    foreach (CatalogIdWithPath catalog in catalogIdsWithPaths)
+                    {
+                        if (!validated)
+                        {
+                            // Get the file hash
+                            uint cryptHashSize = 20;
+                            byte[] cryptHashBytes = new byte[cryptHashSize];
+                            int error;
+                            IntPtr fileHandle = IntPtr.Zero;
+                            using (FileStream payloadStream = File.OpenRead(payloadInfo.FullFileName))
+                            {
+                                // Get the file handle
+                                fileHandle = payloadStream.SafeFileHandle.DangerousGetHandle();
+
+                                // 20 bytes is usually the hash size.  Future hashes may be bigger
+                                if (!VerifyInterop.CryptCATAdminCalcHashFromFileHandle(fileHandle, ref cryptHashSize, cryptHashBytes, 0))
+                                {
+                                    error = Marshal.GetLastWin32Error();
+
+                                    if (VerifyInterop.ErrorInsufficientBuffer == error)
+                                    {
+                                        error = 0;
+                                        cryptHashBytes = new byte[cryptHashSize];
+                                        if (!VerifyInterop.CryptCATAdminCalcHashFromFileHandle(fileHandle, ref cryptHashSize, cryptHashBytes, 0))
+                                        {
+                                            error = Marshal.GetLastWin32Error();
+                                        }
+                                    }
+
+                                    if (0 != error)
+                                    {
+                                        Messaging.Instance.OnMessage(WixErrors.CatalogFileHashFailed(payloadInfo.FullFileName, error));
+                                    }
+                                }
+                            }
+
+                            VerifyInterop.WinTrustCatalogInfo catalogData = new VerifyInterop.WinTrustCatalogInfo();
+                            VerifyInterop.WinTrustData trustData = new VerifyInterop.WinTrustData();
+                            try
+                            {
+                                // Create WINTRUST_CATALOG_INFO structure
+                                catalogData.cbStruct = (uint)Marshal.SizeOf(catalogData);
+                                catalogData.cbCalculatedFileHash = cryptHashSize;
+                                catalogData.pbCalculatedFileHash = Marshal.AllocCoTaskMem((int)cryptHashSize);
+                                Marshal.Copy(cryptHashBytes, 0, catalogData.pbCalculatedFileHash, (int)cryptHashSize);
+
+                                StringBuilder hashString = new StringBuilder();
+                                foreach (byte hashByte in cryptHashBytes)
+                                {
+                                    hashString.Append(hashByte.ToString("X2"));
+                                }
+                                catalogData.pcwszMemberTag = hashString.ToString();
+
+                                // The file names need to be lower case for older OSes
+                                catalogData.pcwszMemberFilePath = payloadInfo.FullFileName.ToLowerInvariant();
+                                catalogData.pcwszCatalogFilePath = catalog.FullPath.ToLowerInvariant();
+
+                                // Create WINTRUST_DATA structure
+                                trustData.cbStruct = (uint)Marshal.SizeOf(trustData);
+                                trustData.dwUIChoice = VerifyInterop.WTD_UI_NONE;
+                                trustData.fdwRevocationChecks = VerifyInterop.WTD_REVOKE_NONE;
+                                trustData.dwUnionChoice = VerifyInterop.WTD_CHOICE_CATALOG;
+                                trustData.dwStateAction = VerifyInterop.WTD_STATEACTION_VERIFY;
+                                trustData.dwProvFlags = VerifyInterop.WTD_REVOCATION_CHECK_NONE;
+
+                                // Create the structure pointers for unmanaged
+                                trustData.pCatalog = Marshal.AllocCoTaskMem(Marshal.SizeOf(catalogData));
+                                Marshal.StructureToPtr(catalogData, trustData.pCatalog, false);
+
+                                // Call WinTrustVerify to validate the file with the catalog
+                                IntPtr noWindow = new IntPtr(-1);
+                                Guid verifyGuid = new Guid(VerifyInterop.GenericVerify2);
+                                long verifyResult = VerifyInterop.WinVerifyTrust(noWindow, ref verifyGuid, ref trustData);
+                                if (0 == verifyResult)
+                                {
+                                    payloadInfo.Catalog = catalog.Id;
+                                    validated = true;
+                                    break;
+                                }
+                            }
+                            finally
+                            {
+                                // Free the structure memory
+                                if (IntPtr.Zero != trustData.pCatalog)
+                                {
+                                    Marshal.FreeCoTaskMem(trustData.pCatalog);
+                                }
+
+                                if (IntPtr.Zero != catalogData.pbCalculatedFileHash)
+                                {
+                                    Marshal.FreeCoTaskMem(catalogData.pbCalculatedFileHash);
+                                }
+                            }
+                        }
+                    }
+
+                    // Error message if the file was not validated by one of the catalogs
+                    if (!validated)
+                    {
+                        Messaging.Instance.OnMessage(WixErrors.CatalogVerificationFailed(payloadInfo.FullFileName));
+                    }
+                }
+            }
+        }
+
+        private class CatalogIdWithPath
+        {
+            public string Id { get; set; }
+
+            public string FullPath { get; set; }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/Databases/AssignMediaCommand.cs b/src/WixToolset.Core/Bind/Databases/AssignMediaCommand.cs
new file mode 100644
index 00000000..5e2650e9
--- /dev/null
+++ b/src/WixToolset.Core/Bind/Databases/AssignMediaCommand.cs
@@ -0,0 +1,314 @@
+// 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.Bind.Databases
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.IO;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+
+    /// <summary>
+    /// AssignMediaCommand assigns files to cabs based on Media or MediaTemplate rows.
+    /// </summary>
+    public class AssignMediaCommand : ICommand
+    {
+        public AssignMediaCommand()
+        {
+            this.CabinetNameTemplate = "Cab{0}.cab";
+        }
+
+        public Output Output { private get; set; }
+
+        public bool FilesCompressed { private get; set; }
+
+        public string CabinetNameTemplate { private get; set; }
+
+        public IEnumerable<FileFacade> FileFacades { private get; set; }
+
+        public TableDefinitionCollection TableDefinitions { private get; set; }
+
+        /// <summary>
+        /// Gets cabinets with their file rows.
+        /// </summary>
+        public Dictionary<MediaRow, IEnumerable<FileFacade>> FileFacadesByCabinetMedia { get; private set; }
+
+        /// <summary>
+        /// Get media rows.
+        /// </summary>
+        public RowDictionary<MediaRow> MediaRows { get; private set; }
+
+        /// <summary>
+        /// Get uncompressed file rows. This will contain file rows of File elements that are marked with compression=no.
+        /// This contains all the files when Package element is marked with compression=no
+        /// </summary>
+        public IEnumerable<FileFacade> UncompressedFileFacades { get; private set; }
+
+        public void Execute()
+        {
+            Dictionary<MediaRow, List<FileFacade>> filesByCabinetMedia = new Dictionary<MediaRow, List<FileFacade>>();
+
+            RowDictionary<MediaRow> mediaRows = new RowDictionary<MediaRow>();
+
+            List<FileFacade> uncompressedFiles = new List<FileFacade>();
+
+            MediaRow mergeModuleMediaRow = null;
+            Table mediaTable = this.Output.Tables["Media"];
+            Table mediaTemplateTable = this.Output.Tables["WixMediaTemplate"];
+
+            // If both tables are authored, it is an error.
+            if ((mediaTemplateTable != null && mediaTemplateTable.Rows.Count > 0) && (mediaTable != null && mediaTable.Rows.Count > 1))
+            {
+                throw new WixException(WixErrors.MediaTableCollision(null));
+            }
+
+            // When building merge module, all the files go to "#MergeModule.CABinet".
+            if (OutputType.Module == this.Output.Type)
+            {
+                Table mergeModuleMediaTable = new Table(null, this.TableDefinitions["Media"]);
+                mergeModuleMediaRow = (MediaRow)mergeModuleMediaTable.CreateRow(null);
+                mergeModuleMediaRow.Cabinet = "#MergeModule.CABinet";
+
+                filesByCabinetMedia.Add(mergeModuleMediaRow, new List<FileFacade>());
+            }
+
+            if (OutputType.Module == this.Output.Type || null == mediaTemplateTable)
+            {
+                this.ManuallyAssignFiles(mediaTable, mergeModuleMediaRow, this.FileFacades, filesByCabinetMedia, mediaRows, uncompressedFiles);
+            }
+            else
+            {
+                this.AutoAssignFiles(mediaTable, this.FileFacades, filesByCabinetMedia, mediaRows, uncompressedFiles);
+            }
+
+            this.FileFacadesByCabinetMedia = new Dictionary<MediaRow, IEnumerable<FileFacade>>();
+
+            foreach (var mediaRowWithFiles in filesByCabinetMedia)
+            {
+                this.FileFacadesByCabinetMedia.Add(mediaRowWithFiles.Key, mediaRowWithFiles.Value);
+            }
+
+            this.MediaRows = mediaRows;
+
+            this.UncompressedFileFacades = uncompressedFiles;
+        }
+
+        /// <summary>
+        /// Assign files to cabinets based on MediaTemplate authoring.
+        /// </summary>
+        /// <param name="fileFacades">FileRowCollection</param>
+        private void AutoAssignFiles(Table mediaTable, IEnumerable<FileFacade> fileFacades, Dictionary<MediaRow, List<FileFacade>> filesByCabinetMedia, RowDictionary<MediaRow> mediaRows, List<FileFacade> uncompressedFiles)
+        {
+            const int MaxCabIndex = 999;
+
+            ulong currentPreCabSize = 0;
+            ulong maxPreCabSizeInBytes;
+            int maxPreCabSizeInMB = 0;
+            int currentCabIndex = 0;
+
+            MediaRow currentMediaRow = null;
+
+            Table mediaTemplateTable = this.Output.Tables["WixMediaTemplate"];
+
+            // Auto assign files to cabinets based on maximum uncompressed media size
+            mediaTable.Rows.Clear();
+            WixMediaTemplateRow mediaTemplateRow = (WixMediaTemplateRow)mediaTemplateTable.Rows[0];
+
+            if (!String.IsNullOrEmpty(mediaTemplateRow.CabinetTemplate))
+            {
+                this.CabinetNameTemplate = mediaTemplateRow.CabinetTemplate;
+            }
+
+            string mumsString = Environment.GetEnvironmentVariable("WIX_MUMS");
+
+            try
+            {
+                // Override authored mums value if environment variable is authored.
+                if (!String.IsNullOrEmpty(mumsString))
+                {
+                    maxPreCabSizeInMB = Int32.Parse(mumsString);
+                }
+                else
+                {
+                    maxPreCabSizeInMB = mediaTemplateRow.MaximumUncompressedMediaSize;
+                }
+
+                maxPreCabSizeInBytes = (ulong)maxPreCabSizeInMB * 1024 * 1024;
+            }
+            catch (FormatException)
+            {
+                throw new WixException(WixErrors.IllegalEnvironmentVariable("WIX_MUMS", mumsString));
+            }
+            catch (OverflowException)
+            {
+                throw new WixException(WixErrors.MaximumUncompressedMediaSizeTooLarge(null, maxPreCabSizeInMB));
+            }
+
+            foreach (FileFacade facade in this.FileFacades)
+            {
+                // When building a product, if the current file is not to be compressed or if
+                // the package set not to be compressed, don't cab it.
+                if (OutputType.Product == this.Output.Type &&
+                    (YesNoType.No == facade.File.Compressed ||
+                    (YesNoType.NotSet == facade.File.Compressed && !this.FilesCompressed)))
+                {
+                    uncompressedFiles.Add(facade);
+                    continue;
+                }
+
+                if (currentCabIndex == MaxCabIndex)
+                {
+                    // Associate current file with last cab (irrespective of the size) and cab index is not incremented anymore.
+                    List<FileFacade> cabinetFiles = filesByCabinetMedia[currentMediaRow];
+                    facade.WixFile.DiskId = currentCabIndex;
+                    cabinetFiles.Add(facade);
+                    continue;
+                }
+
+                // Update current cab size.
+                currentPreCabSize += (ulong)facade.File.FileSize;
+
+                if (currentPreCabSize > maxPreCabSizeInBytes)
+                {
+                    // Overflow due to current file
+                    currentMediaRow = this.AddMediaRow(mediaTemplateRow, mediaTable, ++currentCabIndex);
+                    mediaRows.Add(currentMediaRow);
+                    filesByCabinetMedia.Add(currentMediaRow, new List<FileFacade>());
+
+                    List<FileFacade> cabinetFileRows = filesByCabinetMedia[currentMediaRow];
+                    facade.WixFile.DiskId = currentCabIndex;
+                    cabinetFileRows.Add(facade);
+                    // Now files larger than MaxUncompressedMediaSize will be the only file in its cabinet so as to respect MaxUncompressedMediaSize
+                    currentPreCabSize = (ulong)facade.File.FileSize;
+                }
+                else
+                {
+                    // File fits in the current cab.
+                    if (currentMediaRow == null)
+                    {
+                        // Create new cab and MediaRow
+                        currentMediaRow = this.AddMediaRow(mediaTemplateRow, mediaTable, ++currentCabIndex);
+                        mediaRows.Add(currentMediaRow);
+                        filesByCabinetMedia.Add(currentMediaRow, new List<FileFacade>());
+                    }
+
+                    // Associate current file with current cab.
+                    List<FileFacade> cabinetFiles = filesByCabinetMedia[currentMediaRow];
+                    facade.WixFile.DiskId = currentCabIndex;
+                    cabinetFiles.Add(facade);
+                }
+            }
+
+            // If there are uncompressed files and no MediaRow, create a default one.
+            if (uncompressedFiles.Count > 0 && mediaTable.Rows.Count == 0)
+            {
+                MediaRow defaultMediaRow = (MediaRow)mediaTable.CreateRow(null);
+                defaultMediaRow.DiskId = 1;
+                mediaRows.Add(defaultMediaRow);
+            }
+        }
+
+        /// <summary>
+        /// Assign files to cabinets based on Media authoring.
+        /// </summary>
+        /// <param name="mediaTable"></param>
+        /// <param name="mergeModuleMediaRow"></param>
+        /// <param name="fileFacades"></param>
+        private void ManuallyAssignFiles(Table mediaTable, MediaRow mergeModuleMediaRow, IEnumerable<FileFacade> fileFacades, Dictionary<MediaRow, List<FileFacade>> filesByCabinetMedia, RowDictionary<MediaRow> mediaRows, List<FileFacade> uncompressedFiles)
+        {
+            if (OutputType.Module != this.Output.Type)
+            {
+                if (null != mediaTable)
+                {
+                    Dictionary<string, MediaRow> cabinetMediaRows = new Dictionary<string, MediaRow>(StringComparer.InvariantCultureIgnoreCase);
+                    foreach (MediaRow mediaRow in mediaTable.Rows)
+                    {
+                        // If the Media row has a cabinet, make sure it is unique across all Media rows.
+                        if (!String.IsNullOrEmpty(mediaRow.Cabinet))
+                        {
+                            MediaRow existingRow;
+                            if (cabinetMediaRows.TryGetValue(mediaRow.Cabinet, out existingRow))
+                            {
+                                Messaging.Instance.OnMessage(WixErrors.DuplicateCabinetName(mediaRow.SourceLineNumbers, mediaRow.Cabinet));
+                                Messaging.Instance.OnMessage(WixErrors.DuplicateCabinetName2(existingRow.SourceLineNumbers, existingRow.Cabinet));
+                            }
+                            else
+                            {
+                                cabinetMediaRows.Add(mediaRow.Cabinet, mediaRow);
+                            }
+                        }
+
+                        mediaRows.Add(mediaRow);
+                    }
+                }
+
+                foreach (MediaRow mediaRow in mediaRows.Values)
+                {
+                    if (null != mediaRow.Cabinet)
+                    {
+                        filesByCabinetMedia.Add(mediaRow, new List<FileFacade>());
+                    }
+                }
+            }
+
+            foreach (FileFacade facade in fileFacades)
+            {
+                if (OutputType.Module == this.Output.Type)
+                {
+                    filesByCabinetMedia[mergeModuleMediaRow].Add(facade);
+                }
+                else
+                {
+                    MediaRow mediaRow;
+                    if (!mediaRows.TryGetValue(facade.WixFile.DiskId.ToString(CultureInfo.InvariantCulture), out mediaRow))
+                    {
+                        Messaging.Instance.OnMessage(WixErrors.MissingMedia(facade.File.SourceLineNumbers, facade.WixFile.DiskId));
+                        continue;
+                    }
+
+                    // When building a product, if the current file is not to be compressed or if
+                    // the package set not to be compressed, don't cab it.
+                    if (OutputType.Product == this.Output.Type &&
+                        (YesNoType.No == facade.File.Compressed ||
+                        (YesNoType.NotSet == facade.File.Compressed && !this.FilesCompressed)))
+                    {
+                        uncompressedFiles.Add(facade);
+                    }
+                    else // file is marked compressed.
+                    {
+                        List<FileFacade> cabinetFiles;
+                        if (filesByCabinetMedia.TryGetValue(mediaRow, out cabinetFiles))
+                        {
+                            cabinetFiles.Add(facade);
+                        }
+                        else
+                        {
+                            Messaging.Instance.OnMessage(WixErrors.ExpectedMediaCabinet(facade.File.SourceLineNumbers, facade.File.File, facade.WixFile.DiskId));
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Adds a row to the media table with cab name template filled in.
+        /// </summary>
+        /// <param name="mediaTable"></param>
+        /// <param name="cabIndex"></param>
+        /// <returns></returns>
+        private MediaRow AddMediaRow(WixMediaTemplateRow mediaTemplateRow, Table mediaTable, int cabIndex)
+        {
+            MediaRow currentMediaRow = (MediaRow)mediaTable.CreateRow(mediaTemplateRow.SourceLineNumbers);
+            currentMediaRow.DiskId = cabIndex;
+            currentMediaRow.Cabinet = String.Format(CultureInfo.InvariantCulture, this.CabinetNameTemplate, cabIndex);
+
+            Table wixMediaTable = this.Output.EnsureTable(this.TableDefinitions["WixMedia"]);
+            WixMediaRow row = (WixMediaRow)wixMediaTable.CreateRow(mediaTemplateRow.SourceLineNumbers);
+            row.DiskId = cabIndex;
+            row.CompressionLevel = mediaTemplateRow.CompressionLevel;
+
+            return currentMediaRow;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/Databases/BindSummaryInfoCommand.cs b/src/WixToolset.Core/Bind/Databases/BindSummaryInfoCommand.cs
new file mode 100644
index 00000000..95bd4cf0
--- /dev/null
+++ b/src/WixToolset.Core/Bind/Databases/BindSummaryInfoCommand.cs
@@ -0,0 +1,135 @@
+// 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.Bind.Databases
+{
+    using System;
+    using System.Globalization;
+    using WixToolset.Data;
+
+    /// <summary>
+    /// Binds the summary information table of a database.
+    /// </summary>
+    internal class BindSummaryInfoCommand : ICommand
+    {
+        /// <summary>
+        /// The output to bind.
+        /// </summary>
+        public Output Output { private get; set; }
+
+        /// <summary>
+        /// Returns a flag indicating if files are compressed by default.
+        /// </summary>
+        public bool Compressed { get; private set; }
+
+        /// <summary>
+        /// Returns a flag indicating if uncompressed files use long filenames.
+        /// </summary>
+        public bool LongNames { get; private set; }
+
+        public int InstallerVersion { get; private set; }
+
+        /// <summary>
+        /// Modularization guid, or null if the output is not a module.
+        /// </summary>
+        public string ModularizationGuid { get; private set; }
+
+        public void Execute()
+        {
+            this.Compressed = false;
+            this.LongNames = false;
+            this.InstallerVersion = 0;
+            this.ModularizationGuid = null;
+
+            Table summaryInformationTable = this.Output.Tables["_SummaryInformation"];
+
+            if (null != summaryInformationTable)
+            {
+                bool foundCreateDataTime = false;
+                bool foundLastSaveDataTime = false;
+                bool foundCreatingApplication = false;
+                string now = DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss", CultureInfo.InvariantCulture);
+
+                foreach (Row summaryInformationRow in summaryInformationTable.Rows)
+                {
+                    switch (summaryInformationRow.FieldAsInteger(0))
+                    {
+                        case 1: // PID_CODEPAGE
+                            // make sure the code page is an int and not a web name or null
+                            string codepage = summaryInformationRow.FieldAsString(1);
+
+                            if (null == codepage)
+                            {
+                                codepage = "0";
+                            }
+                            else
+                            {
+                                summaryInformationRow[1] = Common.GetValidCodePage(codepage, false, false, summaryInformationRow.SourceLineNumbers).ToString(CultureInfo.InvariantCulture);
+                            }
+                            break;
+                        case 9: // PID_REVNUMBER
+                            string packageCode = (string)summaryInformationRow[1];
+
+                            if (OutputType.Module == this.Output.Type)
+                            {
+                                this.ModularizationGuid = packageCode.Substring(1, 36).Replace('-', '_');
+                            }
+                            else if ("*" == packageCode)
+                            {
+                                // set the revision number (package/patch code) if it should be automatically generated
+                                summaryInformationRow[1] = Common.GenerateGuid();
+                            }
+                            break;
+                        case 12: // PID_CREATE_DTM
+                            foundCreateDataTime = true;
+                            break;
+                        case 13: // PID_LASTSAVE_DTM
+                            foundLastSaveDataTime = true;
+                            break;
+                        case 14:
+                            this.InstallerVersion = summaryInformationRow.FieldAsInteger(1);
+                            break;
+                        case 15: // PID_WORDCOUNT
+                            if (OutputType.Patch == this.Output.Type)
+                            {
+                                this.LongNames = true;
+                                this.Compressed = true;
+                            }
+                            else
+                            {
+                                this.LongNames = (0 == (summaryInformationRow.FieldAsInteger(1) & 1));
+                                this.Compressed = (2 == (summaryInformationRow.FieldAsInteger(1) & 2));
+                            }
+                            break;
+                        case 18: // PID_APPNAME
+                            foundCreatingApplication = true;
+                            break;
+                    }
+                }
+
+                // add a summary information row for the create time/date property if its not already set
+                if (!foundCreateDataTime)
+                {
+                    Row createTimeDateRow = summaryInformationTable.CreateRow(null);
+                    createTimeDateRow[0] = 12;
+                    createTimeDateRow[1] = now;
+                }
+
+                // add a summary information row for the last save time/date property if its not already set
+                if (!foundLastSaveDataTime)
+                {
+                    Row lastSaveTimeDateRow = summaryInformationTable.CreateRow(null);
+                    lastSaveTimeDateRow[0] = 13;
+                    lastSaveTimeDateRow[1] = now;
+                }
+
+                // add a summary information row for the creating application property if its not already set
+                if (!foundCreatingApplication)
+                {
+                    Row creatingApplicationRow = summaryInformationTable.CreateRow(null);
+                    creatingApplicationRow[0] = 18;
+                    creatingApplicationRow[1] = String.Format(CultureInfo.InvariantCulture, AppCommon.GetCreatingApplicationString());
+                }
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/Databases/CabinetBuilder.cs b/src/WixToolset.Core/Bind/Databases/CabinetBuilder.cs
new file mode 100644
index 00000000..2de6ec25
--- /dev/null
+++ b/src/WixToolset.Core/Bind/Databases/CabinetBuilder.cs
@@ -0,0 +1,176 @@
+// 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.Bind.Databases
+{
+    using System;
+    using System.Collections;
+    using System.IO;
+    using System.Linq;
+    using System.Threading;
+    using WixToolset.Cab;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+
+    /// <summary>
+    /// Builds cabinets using multiple threads. This implements a thread pool that generates cabinets with multiple
+    /// threads. Unlike System.Threading.ThreadPool, it waits until all threads are finished.
+    /// </summary>
+    internal sealed class CabinetBuilder
+    {
+        private Queue cabinetWorkItems;
+        private object lockObject;
+        private int threadCount;
+
+        // Address of Binder's callback function for Cabinet Splitting
+        private IntPtr newCabNamesCallBackAddress;
+
+        public int MaximumCabinetSizeForLargeFileSplitting { get; set; }
+        public int MaximumUncompressedMediaSize { get; set; }
+
+        /// <summary>
+        /// Instantiate a new CabinetBuilder.
+        /// </summary>
+        /// <param name="threadCount">number of threads to use</param>
+        /// <param name="newCabNamesCallBackAddress">Address of Binder's callback function for Cabinet Splitting</param>
+        public CabinetBuilder(int threadCount, IntPtr newCabNamesCallBackAddress)
+        {
+            if (0 >= threadCount)
+            {
+                throw new ArgumentOutOfRangeException("threadCount");
+            }
+
+            this.cabinetWorkItems = new Queue();
+            this.lockObject = new object();
+
+            this.threadCount = threadCount;
+
+            // Set Address of Binder's callback function for Cabinet Splitting
+            this.newCabNamesCallBackAddress = newCabNamesCallBackAddress;
+        }
+
+        /// <summary>
+        /// Enqueues a CabinetWorkItem to the queue.
+        /// </summary>
+        /// <param name="cabinetWorkItem">cabinet work item</param>
+        public void Enqueue(CabinetWorkItem cabinetWorkItem)
+        {
+            this.cabinetWorkItems.Enqueue(cabinetWorkItem);
+        }
+
+        /// <summary>
+        /// Create the queued cabinets.
+        /// </summary>
+        /// <returns>error message number (zero if no error)</returns>
+        public void CreateQueuedCabinets()
+        {
+            // don't create more threads than the number of cabinets to build
+            if (this.cabinetWorkItems.Count < this.threadCount)
+            {
+                this.threadCount = this.cabinetWorkItems.Count;
+            }
+
+            if (0 < this.threadCount)
+            {
+                Thread[] threads = new Thread[this.threadCount];
+
+                for (int i = 0; i < threads.Length; i++)
+                {
+                    threads[i] = new Thread(new ThreadStart(this.ProcessWorkItems));
+                    threads[i].Start();
+                }
+
+                // wait for all threads to finish
+                foreach (Thread thread in threads)
+                {
+                    thread.Join();
+                }
+            }
+        }
+
+        /// <summary>
+        /// This function gets called by multiple threads to do actual work.
+        /// It takes one work item at a time and calls this.CreateCabinet().
+        /// It does not return until cabinetWorkItems queue is empty
+        /// </summary>
+        private void ProcessWorkItems()
+        {
+            try
+            {
+                while (true)
+                {
+                    CabinetWorkItem cabinetWorkItem;
+
+                    lock (this.cabinetWorkItems)
+                    {
+                        // check if there are any more cabinets to create
+                        if (0 == this.cabinetWorkItems.Count)
+                        {
+                            break;
+                        }
+
+                        cabinetWorkItem = (CabinetWorkItem)this.cabinetWorkItems.Dequeue();
+                    }
+
+                    // create a cabinet
+                    this.CreateCabinet(cabinetWorkItem);
+                }
+            }
+            catch (WixException we)
+            {
+                Messaging.Instance.OnMessage(we.Error);
+            }
+            catch (Exception e)
+            {
+                Messaging.Instance.OnMessage(WixErrors.UnexpectedException(e.Message, e.GetType().ToString(), e.StackTrace));
+            }
+        }
+
+        /// <summary>
+        /// Creates a cabinet using the wixcab.dll interop layer.
+        /// </summary>
+        /// <param name="cabinetWorkItem">CabinetWorkItem containing information about the cabinet to create.</param>
+        private void CreateCabinet(CabinetWorkItem cabinetWorkItem)
+        {
+            Messaging.Instance.OnMessage(WixVerboses.CreateCabinet(cabinetWorkItem.CabinetFile));
+
+            int maxCabinetSize = 0; // The value of 0 corresponds to default of 2GB which means no cabinet splitting
+            ulong maxPreCompressedSizeInBytes = 0;
+
+            if (MaximumCabinetSizeForLargeFileSplitting != 0)
+            {
+                // User Specified Max Cab Size for File Splitting, So Check if this cabinet has a single file larger than MaximumUncompressedFileSize
+                // If a file is larger than MaximumUncompressedFileSize, then the cabinet containing it will have only this file
+                if (1 == cabinetWorkItem.FileFacades.Count())
+                {
+                    // Cabinet has Single File, Check if this is Large File than needs Splitting into Multiple cabs
+                    // Get the Value for Max Uncompressed Media Size
+                    maxPreCompressedSizeInBytes = (ulong)MaximumUncompressedMediaSize * 1024 * 1024;
+
+                    foreach (FileFacade facade in cabinetWorkItem.FileFacades) // No other easy way than looping to get the only row
+                    {
+                        if ((ulong)facade.File.FileSize >= maxPreCompressedSizeInBytes)
+                        {
+                            // If file is larger than MaximumUncompressedFileSize set Maximum Cabinet Size for Cabinet Splitting
+                            maxCabinetSize = MaximumCabinetSizeForLargeFileSplitting;
+                        }
+                    }
+                }
+            }
+
+            // create the cabinet file
+            string cabinetFileName = Path.GetFileName(cabinetWorkItem.CabinetFile);
+            string cabinetDirectory = Path.GetDirectoryName(cabinetWorkItem.CabinetFile);
+
+            using (WixCreateCab cab = new WixCreateCab(cabinetFileName, cabinetDirectory, cabinetWorkItem.FileFacades.Count(), maxCabinetSize, cabinetWorkItem.MaxThreshold, cabinetWorkItem.CompressionLevel))
+            {
+                foreach (FileFacade facade in cabinetWorkItem.FileFacades)
+                {
+                    cab.AddFile(facade);
+                }
+
+                cab.Complete(newCabNamesCallBackAddress);
+            }
+        }
+    }
+}
+
diff --git a/src/WixToolset.Core/Bind/Databases/CabinetWorkItem.cs b/src/WixToolset.Core/Bind/Databases/CabinetWorkItem.cs
new file mode 100644
index 00000000..20241bc9
--- /dev/null
+++ b/src/WixToolset.Core/Bind/Databases/CabinetWorkItem.cs
@@ -0,0 +1,78 @@
+// 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.Bind.Databases
+{
+    using System.Collections.Generic;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+
+    /// <summary>
+    /// A cabinet builder work item.
+    /// </summary>
+    internal sealed class CabinetWorkItem
+    {
+        private string cabinetFile;
+        private CompressionLevel compressionLevel;
+        //private BinderFileManager binderFileManager;
+        private int maxThreshold;
+
+        /// <summary>
+        /// Instantiate a new CabinetWorkItem.
+        /// </summary>
+        /// <param name="fileFacades">The collection of files in this cabinet.</param>
+        /// <param name="cabinetFile">The cabinet file.</param>
+        /// <param name="maxThreshold">Maximum threshold for each cabinet.</param>
+        /// <param name="compressionLevel">The compression level of the cabinet.</param>
+        /// <param name="binderFileManager">The binder file manager.</param>
+        public CabinetWorkItem(IEnumerable<FileFacade> fileFacades, string cabinetFile, int maxThreshold, CompressionLevel compressionLevel /*, BinderFileManager binderFileManager*/)
+        {
+            this.cabinetFile = cabinetFile;
+            this.compressionLevel = compressionLevel;
+            this.FileFacades = fileFacades;
+            //this.binderFileManager = binderFileManager;
+            this.maxThreshold = maxThreshold;
+        }
+
+        /// <summary>
+        /// Gets the cabinet file.
+        /// </summary>
+        /// <value>The cabinet file.</value>
+        public string CabinetFile
+        {
+            get { return this.cabinetFile; }
+        }
+
+        /// <summary>
+        /// Gets the compression level of the cabinet.
+        /// </summary>
+        /// <value>The compression level of the cabinet.</value>
+        public CompressionLevel CompressionLevel
+        {
+            get { return this.compressionLevel; }
+        }
+
+        /// <summary>
+        /// Gets the collection of files in this cabinet.
+        /// </summary>
+        /// <value>The collection of files in this cabinet.</value>
+        public IEnumerable<FileFacade> FileFacades { get; private set; }
+
+        /// <summary>
+        /// Gets the binder file manager.
+        /// </summary>
+        /// <value>The binder file manager.</value>
+        //public BinderFileManager BinderFileManager
+        //{
+        //    get { return this.binderFileManager; }
+        //}
+
+        /// <summary>
+        /// Gets the max threshold.
+        /// </summary>
+        /// <value>The maximum threshold for a folder in a cabinet.</value>
+        public int MaxThreshold
+        {
+            get { return this.maxThreshold; }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/Databases/ConfigurationCallback.cs b/src/WixToolset.Core/Bind/Databases/ConfigurationCallback.cs
new file mode 100644
index 00000000..7cb18e0f
--- /dev/null
+++ b/src/WixToolset.Core/Bind/Databases/ConfigurationCallback.cs
@@ -0,0 +1,91 @@
+// 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.Bind.Databases
+{
+    using System;
+    using System.Collections;
+    using System.Globalization;
+    using WixToolset.MergeMod;
+
+    /// <summary>
+    /// Callback object for configurable merge modules.
+    /// </summary>
+    internal sealed class ConfigurationCallback : IMsmConfigureModule
+    {
+        private const int SOk = 0x0;
+        private const int SFalse = 0x1;
+        private Hashtable configurationData;
+
+        /// <summary>
+        /// Creates a ConfigurationCallback object.
+        /// </summary>
+        /// <param name="configData">String to break up into name/value pairs.</param>
+        public ConfigurationCallback(string configData)
+        {
+            if (String.IsNullOrEmpty(configData))
+            {
+                throw new ArgumentNullException("configData");
+            }
+
+            string[] pairs = configData.Split(',');
+            this.configurationData = new Hashtable(pairs.Length);
+            for (int i = 0; i < pairs.Length; ++i)
+            {
+                string[] nameVal = pairs[i].Split('=');
+                string name = nameVal[0];
+                string value = nameVal[1];
+
+                name = name.Replace("%2C", ",");
+                name = name.Replace("%3D", "=");
+                name = name.Replace("%25", "%");
+
+                value = value.Replace("%2C", ",");
+                value = value.Replace("%3D", "=");
+                value = value.Replace("%25", "%");
+
+                this.configurationData[name] = value;
+            }
+        }
+
+        /// <summary>
+        /// Returns text data based on name.
+        /// </summary>
+        /// <param name="name">Name of value to return.</param>
+        /// <param name="configData">Out param to put configuration data into.</param>
+        /// <returns>S_OK if value provided, S_FALSE if not.</returns>
+        public int ProvideTextData(string name, out string configData)
+        {
+            if (this.configurationData.Contains(name))
+            {
+                configData = (string)this.configurationData[name];
+                return SOk;
+            }
+            else
+            {
+                configData = null;
+                return SFalse;
+            }
+        }
+
+        /// <summary>
+        /// Returns integer data based on name.
+        /// </summary>
+        /// <param name="name">Name of value to return.</param>
+        /// <param name="configData">Out param to put configuration data into.</param>
+        /// <returns>S_OK if value provided, S_FALSE if not.</returns>
+        public int ProvideIntegerData(string name, out int configData)
+        {
+            if (this.configurationData.Contains(name))
+            {
+                string val = (string)this.configurationData[name];
+                configData = Convert.ToInt32(val, CultureInfo.InvariantCulture);
+                return SOk;
+            }
+            else
+            {
+                configData = 0;
+                return SFalse;
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/Databases/CopyTransformDataCommand.cs b/src/WixToolset.Core/Bind/Databases/CopyTransformDataCommand.cs
new file mode 100644
index 00000000..af1ab3b0
--- /dev/null
+++ b/src/WixToolset.Core/Bind/Databases/CopyTransformDataCommand.cs
@@ -0,0 +1,606 @@
+// 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.Bind.Databases
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+    using WixToolset.Extensibility;
+    using WixToolset.Core.Native;
+
+    internal class CopyTransformDataCommand : ICommand
+    {
+        public bool CopyOutFileRows { private get; set; }
+
+        public BinderFileManagerCore FileManagerCore { private get; set; }
+
+        public IEnumerable<IBinderFileManager> FileManagers { private get; set; }
+
+        public Output Output { private get; set; }
+
+        public TableDefinitionCollection TableDefinitions { private get; set; }
+
+        public IEnumerable<FileFacade> FileFacades { get; private set; }
+
+        public void Execute()
+        {
+            Debug.Assert(OutputType.Patch != this.Output.Type);
+
+            List<FileFacade> allFileRows = this.CopyOutFileRows ? new List<FileFacade>() : null;
+
+#if false // TODO: Fix this patching related code to work correctly with FileFacades.
+            bool copyToPatch = (allFileRows != null);
+            bool copyFromPatch = !copyToPatch;
+
+            RowDictionary<MediaRow> patchMediaRows = new RowDictionary<MediaRow>();
+
+            Dictionary<int, RowDictionary<WixFileRow>> patchMediaFileRows = new Dictionary<int, RowDictionary<WixFileRow>>();
+
+            Table patchActualFileTable = this.Output.EnsureTable(this.TableDefinitions["File"]);
+            Table patchFileTable = this.Output.EnsureTable(this.TableDefinitions["WixFile"]);
+
+            if (copyFromPatch)
+            {
+                // index patch files by diskId+fileId
+                foreach (WixFileRow patchFileRow in patchFileTable.Rows)
+                {
+                    int diskId = patchFileRow.DiskId;
+                    RowDictionary<WixFileRow> mediaFileRows;
+                    if (!patchMediaFileRows.TryGetValue(diskId, out mediaFileRows))
+                    {
+                        mediaFileRows = new RowDictionary<WixFileRow>();
+                        patchMediaFileRows.Add(diskId, mediaFileRows);
+                    }
+
+                    mediaFileRows.Add(patchFileRow);
+                }
+
+                Table patchMediaTable = this.Output.EnsureTable(this.TableDefinitions["Media"]);
+                patchMediaRows = new RowDictionary<MediaRow>(patchMediaTable);
+            }
+
+            // index paired transforms
+            Dictionary<string, Output> pairedTransforms = new Dictionary<string, Output>();
+            foreach (SubStorage substorage in this.Output.SubStorages)
+            {
+                if (substorage.Name.StartsWith("#"))
+                {
+                    pairedTransforms.Add(substorage.Name.Substring(1), substorage.Data);
+                }
+            }
+
+            try
+            {
+                // copy File bind data into substorages
+                foreach (SubStorage substorage in this.Output.SubStorages)
+                {
+                    if (substorage.Name.StartsWith("#"))
+                    {
+                        // no changes necessary for paired transforms
+                        continue;
+                    }
+
+                    Output mainTransform = substorage.Data;
+                    Table mainWixFileTable = mainTransform.Tables["WixFile"];
+                    Table mainMsiFileHashTable = mainTransform.Tables["MsiFileHash"];
+
+                    this.FileManagerCore.ActiveSubStorage = substorage;
+
+                    RowDictionary<WixFileRow> mainWixFiles = new RowDictionary<WixFileRow>(mainWixFileTable);
+                    RowDictionary<Row> mainMsiFileHashIndex = new RowDictionary<Row>();
+
+                    Table mainFileTable = mainTransform.Tables["File"];
+                    Output pairedTransform = (Output)pairedTransforms[substorage.Name];
+
+                    // copy Media.LastSequence and index the MsiFileHash table if it exists.
+                    if (copyFromPatch)
+                    {
+                        Table pairedMediaTable = pairedTransform.Tables["Media"];
+                        foreach (MediaRow pairedMediaRow in pairedMediaTable.Rows)
+                        {
+                            MediaRow patchMediaRow = patchMediaRows.Get(pairedMediaRow.DiskId);
+                            pairedMediaRow.Fields[1] = patchMediaRow.Fields[1];
+                        }
+
+                        if (null != mainMsiFileHashTable)
+                        {
+                            mainMsiFileHashIndex = new RowDictionary<Row>(mainMsiFileHashTable);
+                        }
+
+                        // Validate file row changes for keypath-related issues
+                        this.ValidateFileRowChanges(mainTransform);
+                    }
+
+                    // Index File table of pairedTransform
+                    Table pairedFileTable = pairedTransform.Tables["File"];
+                    RowDictionary<FileRow> pairedFileRows = new RowDictionary<FileRow>(pairedFileTable);
+
+                    if (null != mainFileTable)
+                    {
+                        if (copyFromPatch)
+                        {
+                            // Remove the MsiFileHash table because it will be updated later with the final file hash for each file
+                            mainTransform.Tables.Remove("MsiFileHash");
+                        }
+
+                        foreach (FileRow mainFileRow in mainFileTable.Rows)
+                        {
+                            if (RowOperation.Delete == mainFileRow.Operation)
+                            {
+                                continue;
+                            }
+                            else if (RowOperation.None == mainFileRow.Operation && !copyToPatch)
+                            {
+                                continue;
+                            }
+
+                            WixFileRow mainWixFileRow = mainWixFiles.Get(mainFileRow.File);
+
+                            if (copyToPatch) // when copying to the patch, we need compare the underlying files and include all file changes.
+                            {
+                                ObjectField objectField = (ObjectField)mainWixFileRow.Fields[6];
+                                FileRow pairedFileRow = pairedFileRows.Get(mainFileRow.File);
+
+                                // If the file is new, we always need to add it to the patch.
+                                if (mainFileRow.Operation != RowOperation.Add)
+                                {
+                                    // If PreviousData doesn't exist, target and upgrade layout point to the same location. No need to compare.
+                                    if (null == objectField.PreviousData)
+                                    {
+                                        if (mainFileRow.Operation == RowOperation.None)
+                                        {
+                                            continue;
+                                        }
+                                    }
+                                    else
+                                    {
+                                        // TODO: should this entire condition be placed in the binder file manager?
+                                        if ((0 == (PatchAttributeType.Ignore & mainWixFileRow.PatchAttributes)) &&
+                                            !this.CompareFiles(objectField.PreviousData.ToString(), objectField.Data.ToString()))
+                                        {
+                                            // If the file is different, we need to mark the mainFileRow and pairedFileRow as modified.
+                                            mainFileRow.Operation = RowOperation.Modify;
+                                            if (null != pairedFileRow)
+                                            {
+                                                // Always patch-added, but never non-compressed.
+                                                pairedFileRow.Attributes |= MsiInterop.MsidbFileAttributesPatchAdded;
+                                                pairedFileRow.Attributes &= ~MsiInterop.MsidbFileAttributesNoncompressed;
+                                                pairedFileRow.Fields[6].Modified = true;
+                                                pairedFileRow.Operation = RowOperation.Modify;
+                                            }
+                                        }
+                                        else
+                                        {
+                                            // The File is same. We need mark all the attributes as unchanged.
+                                            mainFileRow.Operation = RowOperation.None;
+                                            foreach (Field field in mainFileRow.Fields)
+                                            {
+                                                field.Modified = false;
+                                            }
+
+                                            if (null != pairedFileRow)
+                                            {
+                                                pairedFileRow.Attributes &= ~MsiInterop.MsidbFileAttributesPatchAdded;
+                                                pairedFileRow.Fields[6].Modified = false;
+                                                pairedFileRow.Operation = RowOperation.None;
+                                            }
+                                            continue;
+                                        }
+                                    }
+                                }
+                                else if (null != pairedFileRow) // RowOperation.Add
+                                {
+                                    // Always patch-added, but never non-compressed.
+                                    pairedFileRow.Attributes |= MsiInterop.MsidbFileAttributesPatchAdded;
+                                    pairedFileRow.Attributes &= ~MsiInterop.MsidbFileAttributesNoncompressed;
+                                    pairedFileRow.Fields[6].Modified = true;
+                                    pairedFileRow.Operation = RowOperation.Add;
+                                }
+                            }
+
+                            // index patch files by diskId+fileId
+                            int diskId = mainWixFileRow.DiskId;
+
+                            RowDictionary<WixFileRow> mediaFileRows;
+                            if (!patchMediaFileRows.TryGetValue(diskId, out mediaFileRows))
+                            {
+                                mediaFileRows = new RowDictionary<WixFileRow>();
+                                patchMediaFileRows.Add(diskId, mediaFileRows);
+                            }
+
+                            string fileId = mainFileRow.File;
+                            WixFileRow patchFileRow = mediaFileRows.Get(fileId);
+                            if (copyToPatch)
+                            {
+                                if (null == patchFileRow)
+                                {
+                                    FileRow patchActualFileRow = (FileRow)patchFileTable.CreateRow(mainFileRow.SourceLineNumbers);
+                                    patchActualFileRow.CopyFrom(mainFileRow);
+
+                                    patchFileRow = (WixFileRow)patchFileTable.CreateRow(mainFileRow.SourceLineNumbers);
+                                    patchFileRow.CopyFrom(mainWixFileRow);
+
+                                    mediaFileRows.Add(patchFileRow);
+
+                                    allFileRows.Add(new FileFacade(patchActualFileRow, patchFileRow, null)); // TODO: should we be passing along delta information? Probably, right?
+                                }
+                                else
+                                {
+                                    // TODO: confirm the rest of data is identical?
+
+                                    // make sure Source is same. Otherwise we are silently ignoring a file.
+                                    if (0 != String.Compare(patchFileRow.Source, mainWixFileRow.Source, StringComparison.OrdinalIgnoreCase))
+                                    {
+                                        Messaging.Instance.OnMessage(WixErrors.SameFileIdDifferentSource(mainFileRow.SourceLineNumbers, fileId, patchFileRow.Source, mainWixFileRow.Source));
+                                    }
+
+                                    // capture the previous file versions (and associated data) from this targeted instance of the baseline into the current filerow.
+                                    patchFileRow.AppendPreviousDataFrom(mainWixFileRow);
+                                }
+                            }
+                            else
+                            {
+                                // copy data from the patch back to the transform
+                                if (null != patchFileRow)
+                                {
+                                    FileRow pairedFileRow = (FileRow)pairedFileRows.Get(fileId);
+                                    for (int i = 0; i < patchFileRow.Fields.Length; i++)
+                                    {
+                                        string patchValue = patchFileRow[i] == null ? "" : patchFileRow[i].ToString();
+                                        string mainValue = mainFileRow[i] == null ? "" : mainFileRow[i].ToString();
+
+                                        if (1 == i)
+                                        {
+                                            // File.Component_ changes should not come from the shared file rows
+                                            // that contain the file information as each individual transform might
+                                            // have different changes (or no changes at all).
+                                        }
+                                        // File.Attributes should not changed for binary deltas
+                                        else if (6 == i)
+                                        {
+                                            if (null != patchFileRow.Patch)
+                                            {
+                                                // File.Attribute should not change for binary deltas
+                                                pairedFileRow.Attributes = mainFileRow.Attributes;
+                                                mainFileRow.Fields[i].Modified = false;
+                                            }
+                                        }
+                                        // File.Sequence is updated in pairedTransform, not mainTransform
+                                        else if (7 == i)
+                                        {
+                                            // file sequence is updated in Patch table instead of File table for delta patches
+                                            if (null != patchFileRow.Patch)
+                                            {
+                                                pairedFileRow.Fields[i].Modified = false;
+                                            }
+                                            else
+                                            {
+                                                pairedFileRow[i] = patchFileRow[i];
+                                                pairedFileRow.Fields[i].Modified = true;
+                                            }
+                                            mainFileRow.Fields[i].Modified = false;
+                                        }
+                                        else if (patchValue != mainValue)
+                                        {
+                                            mainFileRow[i] = patchFileRow[i];
+                                            mainFileRow.Fields[i].Modified = true;
+                                            if (mainFileRow.Operation == RowOperation.None)
+                                            {
+                                                mainFileRow.Operation = RowOperation.Modify;
+                                            }
+                                        }
+                                    }
+
+                                    // copy MsiFileHash row for this File
+                                    Row patchHashRow;
+                                    if (!mainMsiFileHashIndex.TryGetValue(patchFileRow.File, out patchHashRow))
+                                    {
+                                        patchHashRow = patchFileRow.Hash;
+                                    }
+
+                                    if (null != patchHashRow)
+                                    {
+                                        Table mainHashTable = mainTransform.EnsureTable(this.TableDefinitions["MsiFileHash"]);
+                                        Row mainHashRow = mainHashTable.CreateRow(mainFileRow.SourceLineNumbers);
+                                        for (int i = 0; i < patchHashRow.Fields.Length; i++)
+                                        {
+                                            mainHashRow[i] = patchHashRow[i];
+                                            if (i > 1)
+                                            {
+                                                // assume all hash fields have been modified
+                                                mainHashRow.Fields[i].Modified = true;
+                                            }
+                                        }
+
+                                        // assume the MsiFileHash operation follows the File one
+                                        mainHashRow.Operation = mainFileRow.Operation;
+                                    }
+
+                                    // copy MsiAssemblyName rows for this File
+                                    List<Row> patchAssemblyNameRows = patchFileRow.AssemblyNames;
+                                    if (null != patchAssemblyNameRows)
+                                    {
+                                        Table mainAssemblyNameTable = mainTransform.EnsureTable(this.TableDefinitions["MsiAssemblyName"]);
+                                        foreach (Row patchAssemblyNameRow in patchAssemblyNameRows)
+                                        {
+                                            // Copy if there isn't an identical modified/added row already in the transform.
+                                            bool foundMatchingModifiedRow = false;
+                                            foreach (Row mainAssemblyNameRow in mainAssemblyNameTable.Rows)
+                                            {
+                                                if (RowOperation.None != mainAssemblyNameRow.Operation && mainAssemblyNameRow.GetPrimaryKey('/').Equals(patchAssemblyNameRow.GetPrimaryKey('/')))
+                                                {
+                                                    foundMatchingModifiedRow = true;
+                                                    break;
+                                                }
+                                            }
+
+                                            if (!foundMatchingModifiedRow)
+                                            {
+                                                Row mainAssemblyNameRow = mainAssemblyNameTable.CreateRow(mainFileRow.SourceLineNumbers);
+                                                for (int i = 0; i < patchAssemblyNameRow.Fields.Length; i++)
+                                                {
+                                                    mainAssemblyNameRow[i] = patchAssemblyNameRow[i];
+                                                }
+
+                                                // assume value field has been modified
+                                                mainAssemblyNameRow.Fields[2].Modified = true;
+                                                mainAssemblyNameRow.Operation = mainFileRow.Operation;
+                                            }
+                                        }
+                                    }
+
+                                    // Add patch header for this file
+                                    if (null != patchFileRow.Patch)
+                                    {
+                                        // Add the PatchFiles action automatically to the AdminExecuteSequence and InstallExecuteSequence tables.
+                                        AddPatchFilesActionToSequenceTable(SequenceTable.AdminExecuteSequence, mainTransform, pairedTransform, mainFileRow);
+                                        AddPatchFilesActionToSequenceTable(SequenceTable.InstallExecuteSequence, mainTransform, pairedTransform, mainFileRow);
+
+                                        // Add to Patch table
+                                        Table patchTable = pairedTransform.EnsureTable(this.TableDefinitions["Patch"]);
+                                        if (0 == patchTable.Rows.Count)
+                                        {
+                                            patchTable.Operation = TableOperation.Add;
+                                        }
+
+                                        Row patchRow = patchTable.CreateRow(mainFileRow.SourceLineNumbers);
+                                        patchRow[0] = patchFileRow.File;
+                                        patchRow[1] = patchFileRow.Sequence;
+
+                                        FileInfo patchFile = new FileInfo(patchFileRow.Source);
+                                        patchRow[2] = (int)patchFile.Length;
+                                        patchRow[3] = 0 == (PatchAttributeType.AllowIgnoreOnError & patchFileRow.PatchAttributes) ? 0 : 1;
+
+                                        string streamName = patchTable.Name + "." + patchRow[0] + "." + patchRow[1];
+                                        if (MsiInterop.MsiMaxStreamNameLength < streamName.Length)
+                                        {
+                                            streamName = "_" + Guid.NewGuid().ToString("D").ToUpperInvariant().Replace('-', '_');
+                                            Table patchHeadersTable = pairedTransform.EnsureTable(this.TableDefinitions["MsiPatchHeaders"]);
+                                            if (0 == patchHeadersTable.Rows.Count)
+                                            {
+                                                patchHeadersTable.Operation = TableOperation.Add;
+                                            }
+                                            Row patchHeadersRow = patchHeadersTable.CreateRow(mainFileRow.SourceLineNumbers);
+                                            patchHeadersRow[0] = streamName;
+                                            patchHeadersRow[1] = patchFileRow.Patch;
+                                            patchRow[5] = streamName;
+                                            patchHeadersRow.Operation = RowOperation.Add;
+                                        }
+                                        else
+                                        {
+                                            patchRow[4] = patchFileRow.Patch;
+                                        }
+                                        patchRow.Operation = RowOperation.Add;
+                                    }
+                                }
+                                else
+                                {
+                                    // TODO: throw because all transform rows should have made it into the patch
+                                }
+                            }
+                        }
+                    }
+
+                    if (copyFromPatch)
+                    {
+                        this.Output.Tables.Remove("Media");
+                        this.Output.Tables.Remove("File");
+                        this.Output.Tables.Remove("MsiFileHash");
+                        this.Output.Tables.Remove("MsiAssemblyName");
+                    }
+                }
+            }
+            finally
+            {
+                this.FileManagerCore.ActiveSubStorage = null;
+            }
+#endif
+            this.FileFacades = allFileRows;
+        }
+
+        /// <summary>
+        /// Adds the PatchFiles action to the sequence table if it does not already exist.
+        /// </summary>
+        /// <param name="table">The sequence table to check or modify.</param>
+        /// <param name="mainTransform">The primary authoring transform.</param>
+        /// <param name="pairedTransform">The secondary patch transform.</param>
+        /// <param name="mainFileRow">The file row that contains information about the patched file.</param>
+        private void AddPatchFilesActionToSequenceTable(SequenceTable table, Output mainTransform, Output pairedTransform, Row mainFileRow)
+        {
+            // Find/add PatchFiles action (also determine sequence for it).
+            // Search mainTransform first, then pairedTransform (pairedTransform overrides).
+            bool hasPatchFilesAction = false;
+            int seqInstallFiles = 0;
+            int seqDuplicateFiles = 0;
+            string tableName = table.ToString();
+
+            TestSequenceTableForPatchFilesAction(
+                    mainTransform.Tables[tableName],
+                    ref hasPatchFilesAction,
+                    ref seqInstallFiles,
+                    ref seqDuplicateFiles);
+            TestSequenceTableForPatchFilesAction(
+                    pairedTransform.Tables[tableName],
+                    ref hasPatchFilesAction,
+                    ref seqInstallFiles,
+                    ref seqDuplicateFiles);
+            if (!hasPatchFilesAction)
+            {
+                Table iesTable = pairedTransform.EnsureTable(this.TableDefinitions[tableName]);
+                if (0 == iesTable.Rows.Count)
+                {
+                    iesTable.Operation = TableOperation.Add;
+                }
+
+                Row patchAction = iesTable.CreateRow(null);
+                WixActionRow wixPatchAction = WindowsInstallerStandard.GetStandardActions()[table, "PatchFiles"];
+                int sequence = wixPatchAction.Sequence;
+                // Test for default sequence value's appropriateness
+                if (seqInstallFiles >= sequence || (0 != seqDuplicateFiles && seqDuplicateFiles <= sequence))
+                {
+                    if (0 != seqDuplicateFiles)
+                    {
+                        if (seqDuplicateFiles < seqInstallFiles)
+                        {
+                            throw new WixException(WixErrors.InsertInvalidSequenceActionOrder(mainFileRow.SourceLineNumbers, iesTable.Name, "InstallFiles", "DuplicateFiles", wixPatchAction.Action));
+                        }
+                        else
+                        {
+                            sequence = (seqDuplicateFiles + seqInstallFiles) / 2;
+                            if (seqInstallFiles == sequence || seqDuplicateFiles == sequence)
+                            {
+                                throw new WixException(WixErrors.InsertSequenceNoSpace(mainFileRow.SourceLineNumbers, iesTable.Name, "InstallFiles", "DuplicateFiles", wixPatchAction.Action));
+                            }
+                        }
+                    }
+                    else
+                    {
+                        sequence = seqInstallFiles + 1;
+                    }
+                }
+                patchAction[0] = wixPatchAction.Action;
+                patchAction[1] = wixPatchAction.Condition;
+                patchAction[2] = sequence;
+                patchAction.Operation = RowOperation.Add;
+            }
+        }
+
+        /// <summary>
+        /// Tests sequence table for PatchFiles and associated actions
+        /// </summary>
+        /// <param name="iesTable">The table to test.</param>
+        /// <param name="hasPatchFilesAction">Set to true if PatchFiles action is found. Left unchanged otherwise.</param>
+        /// <param name="seqInstallFiles">Set to sequence value of InstallFiles action if found. Left unchanged otherwise.</param>
+        /// <param name="seqDuplicateFiles">Set to sequence value of DuplicateFiles action if found. Left unchanged otherwise.</param>
+        private static void TestSequenceTableForPatchFilesAction(Table iesTable, ref bool hasPatchFilesAction, ref int seqInstallFiles, ref int seqDuplicateFiles)
+        {
+            if (null != iesTable)
+            {
+                foreach (Row iesRow in iesTable.Rows)
+                {
+                    if (String.Equals("PatchFiles", (string)iesRow[0], StringComparison.Ordinal))
+                    {
+                        hasPatchFilesAction = true;
+                    }
+                    if (String.Equals("InstallFiles", (string)iesRow[0], StringComparison.Ordinal))
+                    {
+                        seqInstallFiles = (int)iesRow.Fields[2].Data;
+                    }
+                    if (String.Equals("DuplicateFiles", (string)iesRow[0], StringComparison.Ordinal))
+                    {
+                        seqDuplicateFiles = (int)iesRow.Fields[2].Data;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Signal a warning if a non-keypath file was changed in a patch without also changing the keypath file of the component.
+        /// </summary>
+        /// <param name="output">The output to validate.</param>
+        private void ValidateFileRowChanges(Output transform)
+        {
+            Table componentTable = transform.Tables["Component"];
+            Table fileTable = transform.Tables["File"];
+
+            // There's no sense validating keypaths if the transform has no component or file table
+            if (componentTable == null || fileTable == null)
+            {
+                return;
+            }
+
+            Dictionary<string, string> componentKeyPath = new Dictionary<string, string>(componentTable.Rows.Count);
+
+            // Index the Component table for non-directory & non-registry key paths.
+            foreach (Row row in componentTable.Rows)
+            {
+                if (null != row.Fields[5].Data &&
+                    0 != ((int)row.Fields[3].Data & MsiInterop.MsidbComponentAttributesRegistryKeyPath))
+                {
+                    componentKeyPath.Add(row.Fields[0].Data.ToString(), row.Fields[5].Data.ToString());
+                }
+            }
+
+            Dictionary<string, string> componentWithChangedKeyPath = new Dictionary<string, string>();
+            Dictionary<string, string> componentWithNonKeyPathChanged = new Dictionary<string, string>();
+            // Verify changes in the file table, now that file diffing has occurred
+            foreach (FileRow row in fileTable.Rows)
+            {
+                string fileId = row.Fields[0].Data.ToString();
+                string componentId = row.Fields[1].Data.ToString();
+
+                if (RowOperation.Modify != row.Operation)
+                {
+                    continue;
+                }
+
+                // If this file is the keypath of a component
+                if (componentKeyPath.ContainsValue(fileId))
+                {
+                    if (!componentWithChangedKeyPath.ContainsKey(componentId))
+                    {
+                        componentWithChangedKeyPath.Add(componentId, fileId);
+                    }
+                }
+                else
+                {
+                    if (!componentWithNonKeyPathChanged.ContainsKey(componentId))
+                    {
+                        componentWithNonKeyPathChanged.Add(componentId, fileId);
+                    }
+                }
+            }
+
+            foreach (KeyValuePair<string, string> componentFile in componentWithNonKeyPathChanged)
+            {
+                // Make sure all changes to non keypath files also had a change in the keypath.
+                if (!componentWithChangedKeyPath.ContainsKey(componentFile.Key) && componentKeyPath.ContainsKey(componentFile.Key))
+                {
+                    Messaging.Instance.OnMessage(WixWarnings.UpdateOfNonKeyPathFile((string)componentFile.Value, (string)componentFile.Key, (string)componentKeyPath[componentFile.Key]));
+                }
+            }
+        }
+
+        private bool CompareFiles(string targetFile, string updatedFile)
+        {
+            bool? compared = null;
+            foreach (IBinderFileManager fileManager in this.FileManagers)
+            {
+                compared = fileManager.CompareFiles(targetFile, updatedFile);
+                if (compared.HasValue)
+                {
+                    break;
+                }
+            }
+
+            if (!compared.HasValue)
+            {
+                throw new InvalidOperationException(); // TODO: something needs to be said here that none of the binder file managers returned a result.
+            }
+
+            return compared.Value;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/Databases/CreateCabinetsCommand.cs b/src/WixToolset.Core/Bind/Databases/CreateCabinetsCommand.cs
new file mode 100644
index 00000000..35c8abb4
--- /dev/null
+++ b/src/WixToolset.Core/Bind/Databases/CreateCabinetsCommand.cs
@@ -0,0 +1,489 @@
+// 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.Bind.Databases
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.IO;
+    using System.Linq;
+    using System.Runtime.InteropServices;
+    using System.Threading;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+    using WixToolset.Extensibility;
+
+    /// <summary>
+    /// Creates cabinet files.
+    /// </summary>
+    internal class CreateCabinetsCommand : ICommand
+    {
+        private List<FileTransfer> fileTransfers;
+
+        private FileSplitCabNamesCallback newCabNamesCallBack;
+
+        private Dictionary<string, string> lastCabinetAddedToMediaTable; // Key is First Cabinet Name, Value is Last Cabinet Added in the Split Sequence
+
+        public CreateCabinetsCommand()
+        {
+            this.fileTransfers = new List<FileTransfer>();
+
+            this.newCabNamesCallBack = NewCabNamesCallBack;
+        }
+
+        /// <summary>
+        /// Sets the number of threads to use for cabinet creation.
+        /// </summary>
+        public int CabbingThreadCount { private get; set; }
+
+        public string TempFilesLocation { private get; set; }
+
+        /// <summary>
+        /// Sets the default compression level to use for cabinets
+        /// that don't have their compression level explicitly set.
+        /// </summary>
+        public CompressionLevel DefaultCompressionLevel { private get; set; }
+
+        public Output Output { private get; set; }
+
+        public IEnumerable<IBinderFileManager> FileManagers { private get; set; }
+
+        public string LayoutDirectory { private get; set; }
+
+        public bool Compressed { private get; set; }
+
+        public Dictionary<MediaRow, IEnumerable<FileFacade>> FileRowsByCabinet { private get; set; }
+
+        public Func<MediaRow, string, string, string> ResolveMedia { private get; set; }
+
+        public TableDefinitionCollection TableDefinitions { private get; set; }
+
+        public Table WixMediaTable { private get; set; }
+
+        public IEnumerable<FileTransfer> FileTransfers { get { return this.fileTransfers; } }
+
+        /// <param name="output">Output to generate image for.</param>
+        /// <param name="fileTransfers">Array of files to be transfered.</param>
+        /// <param name="layoutDirectory">The directory in which the image should be layed out.</param>
+        /// <param name="compressed">Flag if source image should be compressed.</param>
+        /// <returns>The uncompressed file rows.</returns>
+        public void Execute()
+        {
+            RowDictionary<WixMediaRow> wixMediaRows = new RowDictionary<WixMediaRow>(this.WixMediaTable);
+
+            this.lastCabinetAddedToMediaTable = new Dictionary<string, string>();
+
+            this.SetCabbingThreadCount();
+
+            // Send Binder object to Facilitate NewCabNamesCallBack Callback
+            CabinetBuilder cabinetBuilder = new CabinetBuilder(this.CabbingThreadCount, Marshal.GetFunctionPointerForDelegate(this.newCabNamesCallBack));
+
+            // Supply Compile MediaTemplate Attributes to Cabinet Builder
+            int MaximumCabinetSizeForLargeFileSplitting;
+            int MaximumUncompressedMediaSize;
+            this.GetMediaTemplateAttributes(out MaximumCabinetSizeForLargeFileSplitting, out MaximumUncompressedMediaSize);
+            cabinetBuilder.MaximumCabinetSizeForLargeFileSplitting = MaximumCabinetSizeForLargeFileSplitting;
+            cabinetBuilder.MaximumUncompressedMediaSize = MaximumUncompressedMediaSize;
+
+            foreach (var entry in this.FileRowsByCabinet)
+            {
+                MediaRow mediaRow = entry.Key;
+                IEnumerable<FileFacade> files = entry.Value;
+                CompressionLevel compressionLevel = this.DefaultCompressionLevel;
+
+                WixMediaRow wixMediaRow = null;
+                string mediaLayoutFolder = null;
+
+                if (wixMediaRows.TryGetValue(mediaRow.GetKey(), out wixMediaRow))
+                {
+                    mediaLayoutFolder = wixMediaRow.Layout;
+
+                    if (wixMediaRow.CompressionLevel.HasValue)
+                    {
+                        compressionLevel = wixMediaRow.CompressionLevel.Value;
+                    }
+                }
+
+                string cabinetDir = this.ResolveMedia(mediaRow, mediaLayoutFolder, this.LayoutDirectory);
+
+                CabinetWorkItem cabinetWorkItem = this.CreateCabinetWorkItem(this.Output, cabinetDir, mediaRow, compressionLevel, files, this.fileTransfers);
+                if (null != cabinetWorkItem)
+                {
+                    cabinetBuilder.Enqueue(cabinetWorkItem);
+                }
+            }
+
+            // stop processing if an error previously occurred
+            if (Messaging.Instance.EncounteredError)
+            {
+                return;
+            }
+
+            // create queued cabinets with multiple threads
+            cabinetBuilder.CreateQueuedCabinets();
+            if (Messaging.Instance.EncounteredError)
+            {
+                return;
+            }
+        }
+
+        /// <summary>
+        /// Sets the thead count to the number of processors if the current thread count is set to 0.
+        /// </summary>
+        /// <remarks>The thread count value must be greater than 0 otherwise and exception will be thrown.</remarks>
+        private void SetCabbingThreadCount()
+        {
+            // default the number of cabbing threads to the number of processors if it wasn't specified
+            if (0 == this.CabbingThreadCount)
+            {
+                string numberOfProcessors = System.Environment.GetEnvironmentVariable("NUMBER_OF_PROCESSORS");
+
+                try
+                {
+                    if (null != numberOfProcessors)
+                    {
+                        this.CabbingThreadCount = Convert.ToInt32(numberOfProcessors, CultureInfo.InvariantCulture.NumberFormat);
+
+                        if (0 >= this.CabbingThreadCount)
+                        {
+                            throw new WixException(WixErrors.IllegalEnvironmentVariable("NUMBER_OF_PROCESSORS", numberOfProcessors));
+                        }
+                    }
+                    else // default to 1 if the environment variable is not set
+                    {
+                        this.CabbingThreadCount = 1;
+                    }
+
+                    Messaging.Instance.OnMessage(WixVerboses.SetCabbingThreadCount(this.CabbingThreadCount.ToString()));
+                }
+                catch (ArgumentException)
+                {
+                    throw new WixException(WixErrors.IllegalEnvironmentVariable("NUMBER_OF_PROCESSORS", numberOfProcessors));
+                }
+                catch (FormatException)
+                {
+                    throw new WixException(WixErrors.IllegalEnvironmentVariable("NUMBER_OF_PROCESSORS", numberOfProcessors));
+                }
+            }
+        }
+
+
+        /// <summary>
+        /// Creates a work item to create a cabinet.
+        /// </summary>
+        /// <param name="output">Output for the current database.</param>
+        /// <param name="cabinetDir">Directory to create cabinet in.</param>
+        /// <param name="mediaRow">MediaRow containing information about the cabinet.</param>
+        /// <param name="fileFacades">Collection of files in this cabinet.</param>
+        /// <param name="fileTransfers">Array of files to be transfered.</param>
+        /// <returns>created CabinetWorkItem object</returns>
+        private CabinetWorkItem CreateCabinetWorkItem(Output output, string cabinetDir, MediaRow mediaRow, CompressionLevel compressionLevel, IEnumerable<FileFacade> fileFacades, List<FileTransfer> fileTransfers)
+        {
+            CabinetWorkItem cabinetWorkItem = null;
+            string tempCabinetFileX = Path.Combine(this.TempFilesLocation, mediaRow.Cabinet);
+
+            // check for an empty cabinet
+            if (!fileFacades.Any())
+            {
+                string cabinetName = mediaRow.Cabinet;
+
+                // remove the leading '#' from the embedded cabinet name to make the warning easier to understand
+                if (cabinetName.StartsWith("#", StringComparison.Ordinal))
+                {
+                    cabinetName = cabinetName.Substring(1);
+                }
+
+                // If building a patch, remind them to run -p for torch.
+                if (OutputType.Patch == output.Type)
+                {
+                    Messaging.Instance.OnMessage(WixWarnings.EmptyCabinet(mediaRow.SourceLineNumbers, cabinetName, true));
+                }
+                else
+                {
+                    Messaging.Instance.OnMessage(WixWarnings.EmptyCabinet(mediaRow.SourceLineNumbers, cabinetName));
+                }
+            }
+
+            ResolvedCabinet resolvedCabinet = this.ResolveCabinet(tempCabinetFileX, fileFacades);
+
+            // create a cabinet work item if it's not being skipped
+            if (CabinetBuildOption.BuildAndCopy == resolvedCabinet.BuildOption || CabinetBuildOption.BuildAndMove == resolvedCabinet.BuildOption)
+            {
+                int maxThreshold = 0; // default to the threshold for best smartcabbing (makes smallest cabinet).
+
+                cabinetWorkItem = new CabinetWorkItem(fileFacades, resolvedCabinet.Path, maxThreshold, compressionLevel/*, this.FileManager*/);
+            }
+            else // reuse the cabinet from the cabinet cache.
+            {
+                Messaging.Instance.OnMessage(WixVerboses.ReusingCabCache(mediaRow.SourceLineNumbers, mediaRow.Cabinet, resolvedCabinet.Path));
+
+                try
+                {
+                    // Ensure the cached cabinet timestamp is current to prevent perpetual incremental builds. The
+                    // problematic scenario goes like this. Imagine two cabinets in the cache. Update a file that
+                    // goes into one of the cabinets. One cabinet will get rebuilt, the other will be copied from
+                    // the cache. Now the file (an input) has a newer timestamp than the reused cabient (an output)
+                    // causing the project to look like it perpetually needs a rebuild until all of the reused
+                    // cabinets get newer timestamps.
+                    File.SetLastWriteTime(resolvedCabinet.Path, DateTime.Now);
+                }
+                catch (Exception e)
+                {
+                    Messaging.Instance.OnMessage(WixWarnings.CannotUpdateCabCache(mediaRow.SourceLineNumbers, resolvedCabinet.Path, e.Message));
+                }
+            }
+
+            if (mediaRow.Cabinet.StartsWith("#", StringComparison.Ordinal))
+            {
+                Table streamsTable = output.EnsureTable(this.TableDefinitions["_Streams"]);
+
+                Row streamRow = streamsTable.CreateRow(mediaRow.SourceLineNumbers);
+                streamRow[0] = mediaRow.Cabinet.Substring(1);
+                streamRow[1] = resolvedCabinet.Path;
+            }
+            else
+            {
+                string destinationPath = Path.Combine(cabinetDir, mediaRow.Cabinet);
+                FileTransfer transfer;
+                if (FileTransfer.TryCreate(resolvedCabinet.Path, destinationPath, CabinetBuildOption.BuildAndMove == resolvedCabinet.BuildOption, "Cabinet", mediaRow.SourceLineNumbers, out transfer))
+                {
+                    transfer.Built = true;
+                    fileTransfers.Add(transfer);
+                }
+            }
+
+            return cabinetWorkItem;
+        }
+
+        private ResolvedCabinet ResolveCabinet(string cabinetPath, IEnumerable<FileFacade> fileFacades)
+        {
+            ResolvedCabinet resolved = null;
+
+            List<BindFileWithPath> filesWithPath = fileFacades.Select(f => new BindFileWithPath() { Id = f.File.File, Path = f.WixFile.Source }).ToList();
+
+            foreach (IBinderFileManager fileManager in this.FileManagers)
+            {
+                resolved = fileManager.ResolveCabinet(cabinetPath, filesWithPath);
+                if (null != resolved)
+                {
+                    break;
+                }
+            }
+
+            return resolved;
+        }
+
+        /// <summary>
+        /// Delegate for Cabinet Split Callback
+        /// </summary>
+        [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+        internal delegate void FileSplitCabNamesCallback([MarshalAs(UnmanagedType.LPWStr)]string firstCabName, [MarshalAs(UnmanagedType.LPWStr)]string newCabName, [MarshalAs(UnmanagedType.LPWStr)]string fileToken);
+
+        /// <summary>
+        /// Call back to Add File Transfer for new Cab and add new Cab to Media table
+        /// This callback can come from Multiple Cabinet Builder Threads and so should be thread safe
+        /// This callback will not be called in case there is no File splitting. i.e. MaximumCabinetSizeForLargeFileSplitting was not authored
+        /// </summary>
+        /// <param name="firstCabName">The name of splitting cabinet without extention e.g. "cab1".</param>
+        /// <param name="newCabName">The name of the new cabinet that would be formed by splitting e.g. "cab1b.cab"</param>
+        /// <param name="fileToken">The file token of the first file present in the splitting cabinet</param>
+        internal void NewCabNamesCallBack([MarshalAs(UnmanagedType.LPWStr)]string firstCabName, [MarshalAs(UnmanagedType.LPWStr)]string newCabName, [MarshalAs(UnmanagedType.LPWStr)]string fileToken)
+        {
+            // Locking Mutex here as this callback can come from Multiple Cabinet Builder Threads
+            Mutex mutex = new Mutex(false, "WixCabinetSplitBinderCallback");
+            try
+            {
+                if (!mutex.WaitOne(0, false)) // Check if you can get the lock
+                {
+                    // Cound not get the Lock
+                    Messaging.Instance.OnMessage(WixVerboses.CabinetsSplitInParallel());
+                    mutex.WaitOne(); // Wait on other thread
+                }
+
+                string firstCabinetName = firstCabName + ".cab";
+                string newCabinetName = newCabName;
+                bool transferAdded = false; // Used for Error Handling
+
+                // Create File Transfer for new Cabinet using transfer of Base Cabinet
+                foreach (FileTransfer transfer in this.FileTransfers)
+                {
+                    if (firstCabinetName.Equals(Path.GetFileName(transfer.Source), StringComparison.InvariantCultureIgnoreCase))
+                    {
+                        string newCabSourcePath = Path.Combine(Path.GetDirectoryName(transfer.Source), newCabinetName);
+                        string newCabTargetPath = Path.Combine(Path.GetDirectoryName(transfer.Destination), newCabinetName);
+
+                        FileTransfer newTransfer;
+                        if (FileTransfer.TryCreate(newCabSourcePath, newCabTargetPath, transfer.Move, "Cabinet", transfer.SourceLineNumbers, out newTransfer))
+                        {
+                            newTransfer.Built = true;
+                            this.fileTransfers.Add(newTransfer);
+                            transferAdded = true;
+                            break;
+                        }
+                    }
+                }
+
+                // Check if File Transfer was added
+                if (!transferAdded)
+                {
+                    throw new WixException(WixErrors.SplitCabinetCopyRegistrationFailed(newCabinetName, firstCabinetName));
+                }
+
+                // Add the new Cabinets to media table using LastSequence of Base Cabinet
+                Table mediaTable = this.Output.Tables["Media"];
+                Table wixFileTable = this.Output.Tables["WixFile"];
+                int diskIDForLastSplitCabAdded = 0; // The DiskID value for the first cab in this cabinet split chain
+                int lastSequenceForLastSplitCabAdded = 0; // The LastSequence value for the first cab in this cabinet split chain
+                bool lastSplitCabinetFound = false; // Used for Error Handling
+
+                string lastCabinetOfThisSequence = String.Empty;
+                // Get the Value of Last Cabinet Added in this split Sequence from Dictionary
+                if (!this.lastCabinetAddedToMediaTable.TryGetValue(firstCabinetName, out lastCabinetOfThisSequence))
+                {
+                    // If there is no value for this sequence, then use first Cabinet is the last one of this split sequence
+                    lastCabinetOfThisSequence = firstCabinetName;
+                }
+
+                foreach (MediaRow mediaRow in mediaTable.Rows)
+                {
+                    // Get details for the Last Cabinet Added in this Split Sequence
+                    if ((lastSequenceForLastSplitCabAdded == 0) && lastCabinetOfThisSequence.Equals(mediaRow.Cabinet, StringComparison.InvariantCultureIgnoreCase))
+                    {
+                        lastSequenceForLastSplitCabAdded = mediaRow.LastSequence;
+                        diskIDForLastSplitCabAdded = mediaRow.DiskId;
+                        lastSplitCabinetFound = true;
+                    }
+
+                    // Check for Name Collision for the new Cabinet added
+                    if (newCabinetName.Equals(mediaRow.Cabinet, StringComparison.InvariantCultureIgnoreCase))
+                    {
+                        // Name Collision of generated Split Cabinet Name and user Specified Cab name for current row
+                        throw new WixException(WixErrors.SplitCabinetNameCollision(newCabinetName, firstCabinetName));
+                    }
+                }
+
+                // Check if the last Split Cabinet was found in the Media Table
+                if (!lastSplitCabinetFound)
+                {
+                    throw new WixException(WixErrors.SplitCabinetInsertionFailed(newCabinetName, firstCabinetName, lastCabinetOfThisSequence));
+                }
+
+                // The new Row has to be inserted just after the last cab in this cabinet split chain according to DiskID Sort
+                // This is because the FDI Extract requires DiskID of Split Cabinets to be continuous. It Fails otherwise with 
+                // Error 2350 (FDI Server Error) as next DiskID did not have the right split cabinet during extraction
+                MediaRow newMediaRow = (MediaRow)mediaTable.CreateRow(null);
+                newMediaRow.Cabinet = newCabinetName;
+                newMediaRow.DiskId = diskIDForLastSplitCabAdded + 1; // When Sorted with DiskID, this new Cabinet Row is an Insertion
+                newMediaRow.LastSequence = lastSequenceForLastSplitCabAdded;
+
+                // Now increment the DiskID for all rows that come after the newly inserted row to Ensure that DiskId is unique
+                foreach (MediaRow mediaRow in mediaTable.Rows)
+                {
+                    // Check if this row comes after inserted row and it is not the new cabinet inserted row
+                    if (mediaRow.DiskId >= newMediaRow.DiskId && !newCabinetName.Equals(mediaRow.Cabinet, StringComparison.InvariantCultureIgnoreCase))
+                    {
+                        mediaRow.DiskId++; // Increment DiskID
+                    }
+                }
+
+                // Now Increment DiskID for All files Rows so that they refer to the right Media Row
+                foreach (WixFileRow wixFileRow in wixFileTable.Rows)
+                {
+                    // Check if this row comes after inserted row and if this row is not the file that has to go into the current cabinet
+                    // This check will work as we have only one large file in every splitting cabinet
+                    // If we want to support splitting cabinet with more large files we need to update this code
+                    if (wixFileRow.DiskId >= newMediaRow.DiskId && !wixFileRow.File.Equals(fileToken, StringComparison.InvariantCultureIgnoreCase))
+                    {
+                        wixFileRow.DiskId++; // Increment DiskID
+                    }
+                }
+
+                // Update the Last Cabinet Added in the Split Sequence in Dictionary for future callback
+                this.lastCabinetAddedToMediaTable[firstCabinetName] = newCabinetName;
+
+                mediaTable.ValidateRows(); // Valdiates DiskDIs, throws Exception as Wix Error if validation fails
+            }
+            finally
+            {
+                // Releasing the Mutex here
+                mutex.ReleaseMutex();
+            }
+        }
+
+
+        /// <summary>
+        /// Gets Compiler Values of MediaTemplate Attributes governing Maximum Cabinet Size after applying Environment Variable Overrides
+        /// </summary>
+        /// <param name="output">Output to generate image for.</param>
+        /// <param name="fileRows">The indexed file rows.</param>
+        private void GetMediaTemplateAttributes(out int maxCabSizeForLargeFileSplitting, out int maxUncompressedMediaSize)
+        {
+            // Get Environment Variable Overrides for MediaTemplate Attributes governing Maximum Cabinet Size
+            string mcslfsString = Environment.GetEnvironmentVariable("WIX_MCSLFS");
+            string mumsString = Environment.GetEnvironmentVariable("WIX_MUMS");
+            int maxCabSizeForLargeFileInMB = 0;
+            int maxPreCompressedSizeInMB = 0;
+            ulong testOverFlow = 0;
+
+            // Supply Compile MediaTemplate Attributes to Cabinet Builder
+            Table mediaTemplateTable = this.Output.Tables["WixMediaTemplate"];
+            if (mediaTemplateTable != null)
+            {
+                WixMediaTemplateRow mediaTemplateRow = (WixMediaTemplateRow)mediaTemplateTable.Rows[0];
+
+                // Get the Value for Max Cab Size for File Splitting
+                try
+                {
+                    // Override authored mcslfs value if environment variable is authored.
+                    if (!String.IsNullOrEmpty(mcslfsString))
+                    {
+                        maxCabSizeForLargeFileInMB = Int32.Parse(mcslfsString);
+                    }
+                    else
+                    {
+                        maxCabSizeForLargeFileInMB = mediaTemplateRow.MaximumCabinetSizeForLargeFileSplitting;
+                    }
+                    testOverFlow = (ulong)maxCabSizeForLargeFileInMB * 1024 * 1024;
+                }
+                catch (FormatException)
+                {
+                    throw new WixException(WixErrors.IllegalEnvironmentVariable("WIX_MCSLFS", mcslfsString));
+                }
+                catch (OverflowException)
+                {
+                    throw new WixException(WixErrors.MaximumCabinetSizeForLargeFileSplittingTooLarge(null, maxCabSizeForLargeFileInMB, CompilerCore.MaxValueOfMaxCabSizeForLargeFileSplitting));
+                }
+
+                try
+                {
+                    // Override authored mums value if environment variable is authored.
+                    if (!String.IsNullOrEmpty(mumsString))
+                    {
+                        maxPreCompressedSizeInMB = Int32.Parse(mumsString);
+                    }
+                    else
+                    {
+                        maxPreCompressedSizeInMB = mediaTemplateRow.MaximumUncompressedMediaSize;
+                    }
+                    testOverFlow = (ulong)maxPreCompressedSizeInMB * 1024 * 1024;
+                }
+                catch (FormatException)
+                {
+                    throw new WixException(WixErrors.IllegalEnvironmentVariable("WIX_MUMS", mumsString));
+                }
+                catch (OverflowException)
+                {
+                    throw new WixException(WixErrors.MaximumUncompressedMediaSizeTooLarge(null, maxPreCompressedSizeInMB));
+                }
+
+                maxCabSizeForLargeFileSplitting = maxCabSizeForLargeFileInMB;
+                maxUncompressedMediaSize = maxPreCompressedSizeInMB;
+            }
+            else
+            {
+                maxCabSizeForLargeFileSplitting = 0;
+                maxUncompressedMediaSize = CompilerCore.DefaultMaximumUncompressedMediaSize;
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/Databases/CreateDeltaPatchesCommand.cs b/src/WixToolset.Core/Bind/Databases/CreateDeltaPatchesCommand.cs
new file mode 100644
index 00000000..933a1ea8
--- /dev/null
+++ b/src/WixToolset.Core/Bind/Databases/CreateDeltaPatchesCommand.cs
@@ -0,0 +1,86 @@
+// 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.Bind.Databases
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.IO;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+
+    /// <summary>
+    /// Creates delta patches and updates the appropriate rows to point to the newly generated patches.
+    /// </summary>
+    internal class CreateDeltaPatchesCommand : ICommand
+    {
+        public IEnumerable<FileFacade> FileFacades { private get; set; }
+
+        public Table WixPatchIdTable { private get; set; }
+
+        public string TempFilesLocation { private get; set; }
+
+        public void Execute()
+        {
+            bool optimizePatchSizeForLargeFiles = false;
+            PatchAPI.PatchInterop.PatchSymbolFlagsType apiPatchingSymbolFlags = 0;
+
+            if (null != this.WixPatchIdTable)
+            {
+                Row row = this.WixPatchIdTable.Rows[0];
+                if (null != row)
+                {
+                    if (null != row[2])
+                    {
+                        optimizePatchSizeForLargeFiles = (1 == Convert.ToUInt32(row[2], CultureInfo.InvariantCulture));
+                    }
+
+                    if (null != row[3])
+                    {
+                        apiPatchingSymbolFlags = (PatchAPI.PatchInterop.PatchSymbolFlagsType)Convert.ToUInt32(row[3], CultureInfo.InvariantCulture);
+                    }
+                }
+            }
+
+            foreach (FileFacade facade in this.FileFacades)
+            {
+                if (RowOperation.Modify == facade.File.Operation &&
+                    0 != (facade.WixFile.PatchAttributes & PatchAttributeType.IncludeWholeFile))
+                {
+                    string deltaBase = String.Concat("delta_", facade.File.File);
+                    string deltaFile = Path.Combine(this.TempFilesLocation, String.Concat(deltaBase, ".dpf"));
+                    string headerFile = Path.Combine(this.TempFilesLocation, String.Concat(deltaBase, ".phd"));
+
+                    bool retainRangeWarning = false;
+
+                    if (PatchAPI.PatchInterop.CreateDelta(
+                            deltaFile,
+                            facade.WixFile.Source,
+                            facade.DeltaPatchFile.Symbols,
+                            facade.DeltaPatchFile.RetainOffsets,
+                            new[] { facade.WixFile.PreviousSource },
+                            facade.DeltaPatchFile.PreviousSymbols.Split(new[] { ';' }),
+                            facade.DeltaPatchFile.PreviousIgnoreLengths.Split(new[] { ';' }),
+                            facade.DeltaPatchFile.PreviousIgnoreOffsets.Split(new[] { ';' }),
+                            facade.DeltaPatchFile.PreviousRetainLengths.Split(new[] { ';' }),
+                            facade.DeltaPatchFile.PreviousRetainOffsets.Split(new[] { ';' }),
+                            apiPatchingSymbolFlags,
+                            optimizePatchSizeForLargeFiles,
+                            out retainRangeWarning))
+                    {
+                        PatchAPI.PatchInterop.ExtractDeltaHeader(deltaFile, headerFile);
+
+                        facade.WixFile.Source = deltaFile;
+                        facade.WixFile.DeltaPatchHeaderSource = headerFile;
+                    }
+
+                    if (retainRangeWarning)
+                    {
+                        // TODO: get patch family to add to warning message for PatchWiz parity.
+                        Messaging.Instance.OnMessage(WixWarnings.RetainRangeMismatch(facade.File.SourceLineNumbers, facade.File.File));
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/Databases/CreateSpecialPropertiesCommand.cs b/src/WixToolset.Core/Bind/Databases/CreateSpecialPropertiesCommand.cs
new file mode 100644
index 00000000..5db2768b
--- /dev/null
+++ b/src/WixToolset.Core/Bind/Databases/CreateSpecialPropertiesCommand.cs
@@ -0,0 +1,68 @@
+// 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.Bind.Databases
+{
+    using System;
+    using System.Collections.Generic;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+
+    internal class CreateSpecialPropertiesCommand : ICommand
+    {
+        public Table PropertyTable { private get; set; }
+
+        public Table WixPropertyTable { private get; set; }
+
+        public void Execute()
+        {
+            // Create the special properties.
+            if (null != this.WixPropertyTable)
+            {
+                // Create lists of the properties that contribute to the special lists of properties.
+                SortedSet<string> adminProperties = new SortedSet<string>();
+                SortedSet<string> secureProperties = new SortedSet<string>();
+                SortedSet<string> hiddenProperties = new SortedSet<string>();
+
+                foreach (WixPropertyRow wixPropertyRow in this.WixPropertyTable.Rows)
+                {
+                    if (wixPropertyRow.Admin)
+                    {
+                        adminProperties.Add(wixPropertyRow.Id);
+                    }
+
+                    if (wixPropertyRow.Hidden)
+                    {
+                        hiddenProperties.Add(wixPropertyRow.Id);
+                    }
+
+                    if (wixPropertyRow.Secure)
+                    {
+                        secureProperties.Add(wixPropertyRow.Id);
+                    }
+                }
+
+                Table propertyTable = this.PropertyTable;
+                if (0 < adminProperties.Count)
+                {
+                    PropertyRow row = (PropertyRow)propertyTable.CreateRow(null);
+                    row.Property = "AdminProperties";
+                    row.Value = String.Join(";", adminProperties);
+                }
+
+                if (0 < secureProperties.Count)
+                {
+                    PropertyRow row = (PropertyRow)propertyTable.CreateRow(null);
+                    row.Property = "SecureCustomProperties";
+                    row.Value = String.Join(";", secureProperties);
+                }
+
+                if (0 < hiddenProperties.Count)
+                {
+                    PropertyRow row = (PropertyRow)propertyTable.CreateRow(null);
+                    row.Property = "MsiHiddenProperties";
+                    row.Value = String.Join(";", hiddenProperties);
+                }
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/Databases/ExtractMergeModuleFilesCommand.cs b/src/WixToolset.Core/Bind/Databases/ExtractMergeModuleFilesCommand.cs
new file mode 100644
index 00000000..bee1488b
--- /dev/null
+++ b/src/WixToolset.Core/Bind/Databases/ExtractMergeModuleFilesCommand.cs
@@ -0,0 +1,225 @@
+// 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.Bind.Databases
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using System.Globalization;
+    using System.IO;
+    using System.Linq;
+    using System.Runtime.InteropServices;
+    using WixToolset.Cab;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+    using WixToolset.MergeMod;
+    using WixToolset.Msi;
+    using WixToolset.Core.Native;
+
+    /// <summary>
+    /// Retrieve files information and extract them from merge modules.
+    /// </summary>
+    internal class ExtractMergeModuleFilesCommand : ICommand
+    {
+        public IEnumerable<FileFacade> FileFacades { private get; set; }
+
+        public Table FileTable { private get; set; }
+
+        public Table WixFileTable { private get; set; }
+
+        public Table WixMergeTable { private get; set; }
+
+        public int OutputInstallerVersion { private get; set; }
+
+        public bool SuppressLayout { private get; set; }
+
+        public string TempFilesLocation { private get; set; }
+
+        public IEnumerable<FileFacade> MergeModulesFileFacades { get; private set; }
+
+        public void Execute()
+        {
+            List<FileFacade> mergeModulesFileFacades = new List<FileFacade>();
+
+            IMsmMerge2 merge = MsmInterop.GetMsmMerge();
+
+            // Index all of the file rows to be able to detect collisions with files in the Merge Modules.
+            // It may seem a bit expensive to build up this index solely for the purpose of checking collisions
+            // and you may be thinking, "Surely, we must need the file rows indexed elsewhere." It turns out
+            // there are other cases where we need all the file rows indexed, however they are not common cases.
+            // Now since Merge Modules are already slow and generally less desirable than .wixlibs we'll let
+            // this case be slightly more expensive because the cost of maintaining an indexed file row collection
+            // is a lot more costly for the common cases.
+            Dictionary<string, FileFacade> indexedFileFacades = this.FileFacades.ToDictionary(f => f.File.File, StringComparer.Ordinal);
+
+            foreach (WixMergeRow wixMergeRow in this.WixMergeTable.Rows)
+            {
+                bool containsFiles = this.CreateFacadesForMergeModuleFiles(wixMergeRow, mergeModulesFileFacades, indexedFileFacades);
+
+                // If the module has files and creating layout
+                if (containsFiles && !this.SuppressLayout)
+                {
+                    this.ExtractFilesFromMergeModule(merge, wixMergeRow);
+                }
+            }
+
+            this.MergeModulesFileFacades = mergeModulesFileFacades;
+        }
+
+        private bool CreateFacadesForMergeModuleFiles(WixMergeRow wixMergeRow, List<FileFacade> mergeModulesFileFacades, Dictionary<string, FileFacade> indexedFileFacades)
+        {
+            bool containsFiles = false;
+
+            try
+            {
+                // read the module's File table to get its FileMediaInformation entries and gather any other information needed from the module.
+                using (Database db = new Database(wixMergeRow.SourceFile, OpenDatabase.ReadOnly))
+                {
+                    if (db.TableExists("File") && db.TableExists("Component"))
+                    {
+                        Dictionary<string, FileFacade> uniqueModuleFileIdentifiers = new Dictionary<string, FileFacade>(StringComparer.OrdinalIgnoreCase);
+
+                        using (View view = db.OpenExecuteView("SELECT `File`, `Directory_` FROM `File`, `Component` WHERE `Component_`=`Component`"))
+                        {
+                            // add each file row from the merge module into the file row collection (check for errors along the way)
+                            while (true)
+                            {
+                                using (Record record = view.Fetch())
+                                {
+                                    if (null == record)
+                                    {
+                                        break;
+                                    }
+
+                                    // NOTE: this is very tricky - the merge module file rows are not added to the
+                                    // file table because they should not be created via idt import.  Instead, these
+                                    // rows are created by merging in the actual modules.
+                                    FileRow fileRow = (FileRow)this.FileTable.CreateRow(wixMergeRow.SourceLineNumbers, false);
+                                    fileRow.File = record[1];
+                                    fileRow.Compressed = wixMergeRow.FileCompression;
+
+                                    WixFileRow wixFileRow = (WixFileRow)this.WixFileTable.CreateRow(wixMergeRow.SourceLineNumbers, false);
+                                    wixFileRow.Directory = record[2];
+                                    wixFileRow.DiskId = wixMergeRow.DiskId;
+                                    wixFileRow.PatchGroup = -1;
+                                    wixFileRow.Source = String.Concat(this.TempFilesLocation, Path.DirectorySeparatorChar, "MergeId.", wixMergeRow.Number.ToString(CultureInfo.InvariantCulture), Path.DirectorySeparatorChar, record[1]);
+
+                                    FileFacade mergeModuleFileFacade = new FileFacade(true, fileRow, wixFileRow);
+
+                                    FileFacade collidingFacade;
+
+                                    // If case-sensitive collision with another merge module or a user-authored file identifier.
+                                    if (indexedFileFacades.TryGetValue(mergeModuleFileFacade.File.File, out collidingFacade))
+                                    {
+                                        Messaging.Instance.OnMessage(WixErrors.DuplicateModuleFileIdentifier(wixMergeRow.SourceLineNumbers, wixMergeRow.Id, collidingFacade.File.File));
+                                    }
+                                    else if (uniqueModuleFileIdentifiers.TryGetValue(mergeModuleFileFacade.File.File, out collidingFacade)) // case-insensitive collision with another file identifier in the same merge module
+                                    {
+                                        Messaging.Instance.OnMessage(WixErrors.DuplicateModuleCaseInsensitiveFileIdentifier(wixMergeRow.SourceLineNumbers, wixMergeRow.Id, mergeModuleFileFacade.File.File, collidingFacade.File.File));
+                                    }
+                                    else // no collision
+                                    {
+                                        mergeModulesFileFacades.Add(mergeModuleFileFacade);
+
+                                        // Keep updating the indexes as new rows are added.
+                                        indexedFileFacades.Add(mergeModuleFileFacade.File.File, mergeModuleFileFacade);
+                                        uniqueModuleFileIdentifiers.Add(mergeModuleFileFacade.File.File, mergeModuleFileFacade);
+                                    }
+
+                                    containsFiles = true;
+                                }
+                            }
+                        }
+                    }
+
+                    // Get the summary information to detect the Schema
+                    using (SummaryInformation summaryInformation = new SummaryInformation(db))
+                    {
+                        string moduleInstallerVersionString = summaryInformation.GetProperty(14);
+
+                        try
+                        {
+                            int moduleInstallerVersion = Convert.ToInt32(moduleInstallerVersionString, CultureInfo.InvariantCulture);
+                            if (moduleInstallerVersion > this.OutputInstallerVersion)
+                            {
+                                Messaging.Instance.OnMessage(WixWarnings.InvalidHigherInstallerVersionInModule(wixMergeRow.SourceLineNumbers, wixMergeRow.Id, moduleInstallerVersion, this.OutputInstallerVersion));
+                            }
+                        }
+                        catch (FormatException)
+                        {
+                            throw new WixException(WixErrors.MissingOrInvalidModuleInstallerVersion(wixMergeRow.SourceLineNumbers, wixMergeRow.Id, wixMergeRow.SourceFile, moduleInstallerVersionString));
+                        }
+                    }
+                }
+            }
+            catch (FileNotFoundException)
+            {
+                throw new WixException(WixErrors.FileNotFound(wixMergeRow.SourceLineNumbers, wixMergeRow.SourceFile));
+            }
+            catch (Win32Exception)
+            {
+                throw new WixException(WixErrors.CannotOpenMergeModule(wixMergeRow.SourceLineNumbers, wixMergeRow.Id, wixMergeRow.SourceFile));
+            }
+
+            return containsFiles;
+        }
+
+        private void ExtractFilesFromMergeModule(IMsmMerge2 merge, WixMergeRow wixMergeRow)
+        {
+            bool moduleOpen = false;
+            short mergeLanguage;
+
+            try
+            {
+                mergeLanguage = Convert.ToInt16(wixMergeRow.Language, CultureInfo.InvariantCulture);
+            }
+            catch (System.FormatException)
+            {
+                Messaging.Instance.OnMessage(WixErrors.InvalidMergeLanguage(wixMergeRow.SourceLineNumbers, wixMergeRow.Id, wixMergeRow.Language));
+                return;
+            }
+
+            try
+            {
+                merge.OpenModule(wixMergeRow.SourceFile, mergeLanguage);
+                moduleOpen = true;
+
+                string safeMergeId = wixMergeRow.Number.ToString(CultureInfo.InvariantCulture.NumberFormat);
+
+                // extract the module cabinet, then explode all of the files to a temp directory
+                string moduleCabPath = String.Concat(this.TempFilesLocation, Path.DirectorySeparatorChar, safeMergeId, ".module.cab");
+                merge.ExtractCAB(moduleCabPath);
+
+                string mergeIdPath = String.Concat(this.TempFilesLocation, Path.DirectorySeparatorChar, "MergeId.", safeMergeId);
+                Directory.CreateDirectory(mergeIdPath);
+
+                using (WixExtractCab extractCab = new WixExtractCab())
+                {
+                    try
+                    {
+                        extractCab.Extract(moduleCabPath, mergeIdPath);
+                    }
+                    catch (FileNotFoundException)
+                    {
+                        throw new WixException(WixErrors.CabFileDoesNotExist(moduleCabPath, wixMergeRow.SourceFile, mergeIdPath));
+                    }
+                    catch
+                    {
+                        throw new WixException(WixErrors.CabExtractionFailed(moduleCabPath, wixMergeRow.SourceFile, mergeIdPath));
+                    }
+                }
+            }
+            catch (COMException ce)
+            {
+                throw new WixException(WixErrors.UnableToOpenModule(wixMergeRow.SourceLineNumbers, wixMergeRow.SourceFile, ce.Message));
+            }
+            finally
+            {
+                if (moduleOpen)
+                {
+                    merge.CloseModule();
+                }
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/Databases/FileFacade.cs b/src/WixToolset.Core/Bind/Databases/FileFacade.cs
new file mode 100644
index 00000000..37115c97
--- /dev/null
+++ b/src/WixToolset.Core/Bind/Databases/FileFacade.cs
@@ -0,0 +1,44 @@
+// 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.Bind.Databases
+{
+    using System.Collections.Generic;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+
+    public class FileFacade
+    {
+        public FileFacade(FileRow file, WixFileRow wixFile, WixDeltaPatchFileRow deltaPatchFile)
+        {
+            this.File = file;
+            this.WixFile = wixFile;
+            this.DeltaPatchFile = deltaPatchFile;
+        }
+
+        public FileFacade(bool fromModule, FileRow file, WixFileRow wixFile)
+        {
+            this.FromModule = fromModule;
+            this.File = file;
+            this.WixFile = wixFile;
+        }
+
+        public bool FromModule { get; private set; }
+
+        public FileRow File { get; private set; }
+
+        public WixFileRow WixFile { get; private set; }
+
+        public WixDeltaPatchFileRow DeltaPatchFile { get; private set; }
+
+        /// <summary>
+        /// Gets the set of MsiAssemblyName rows created for this file.
+        /// </summary>
+        /// <value>RowCollection of MsiAssemblyName table.</value>
+        public List<Row> AssemblyNames { get; set; }
+
+        /// <summary>
+        /// Gets or sets the MsiFileHash row for this file.
+        /// </summary>
+        public Row Hash { get; set; }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/Databases/GetFileFacadesCommand.cs b/src/WixToolset.Core/Bind/Databases/GetFileFacadesCommand.cs
new file mode 100644
index 00000000..b6bcd3af
--- /dev/null
+++ b/src/WixToolset.Core/Bind/Databases/GetFileFacadesCommand.cs
@@ -0,0 +1,148 @@
+// 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.Bind.Databases
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Linq;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+
+    internal class GetFileFacadesCommand : ICommand
+    {
+        public Table FileTable { private get; set; }
+
+        public Table WixFileTable { private get; set; }
+
+        public Table WixDeltaPatchFileTable { private get; set; }
+
+        public Table WixDeltaPatchSymbolPathsTable { private get; set; }
+
+        public List<FileFacade> FileFacades { get; private set; }
+
+        public void Execute()
+        {
+            List<FileFacade> facades = new List<FileFacade>(this.FileTable.Rows.Count);
+
+            RowDictionary<WixFileRow> wixFiles = new RowDictionary<WixFileRow>(this.WixFileTable);
+            RowDictionary<WixDeltaPatchFileRow> deltaPatchFiles = new RowDictionary<WixDeltaPatchFileRow>(this.WixDeltaPatchFileTable);
+
+            foreach (FileRow file in this.FileTable.Rows)
+            {
+                WixDeltaPatchFileRow deltaPatchFile = null;
+
+                deltaPatchFiles.TryGetValue(file.File, out deltaPatchFile);
+
+                facades.Add(new FileFacade(file, wixFiles[file.File], deltaPatchFile));
+            }
+
+            if (null != this.WixDeltaPatchSymbolPathsTable)
+            {
+                this.ResolveDeltaPatchSymbolPaths(deltaPatchFiles, facades);
+            }
+
+            this.FileFacades = facades;
+        }
+
+        /// <summary>
+        /// Merge data from the WixPatchSymbolPaths rows into the WixDeltaPatchFile rows.
+        /// </summary>
+        public RowDictionary<WixDeltaPatchFileRow> ResolveDeltaPatchSymbolPaths(RowDictionary<WixDeltaPatchFileRow> deltaPatchFiles, IEnumerable<FileFacade> facades)
+        {
+            ILookup<string, FileFacade> filesByComponent = null;
+            ILookup<string, FileFacade> filesByDirectory = null;
+            ILookup<string, FileFacade> filesByDiskId = null;
+
+            foreach (WixDeltaPatchSymbolPathsRow row in this.WixDeltaPatchSymbolPathsTable.RowsAs<WixDeltaPatchSymbolPathsRow>().OrderBy(r => r.Type))
+            {
+                switch (row.Type)
+                {
+                    case SymbolPathType.File:
+                        this.MergeSymbolPaths(row, deltaPatchFiles[row.Id]);
+                        break;
+
+                    case SymbolPathType.Component:
+                        if (null == filesByComponent)
+                        {
+                            filesByComponent = facades.ToLookup(f => f.File.Component);
+                        }
+
+                        foreach (FileFacade facade in filesByComponent[row.Id])
+                        {
+                            this.MergeSymbolPaths(row, deltaPatchFiles[facade.File.File]);
+                        }
+                        break;
+
+                    case SymbolPathType.Directory:
+                        if (null == filesByDirectory)
+                        {
+                            filesByDirectory = facades.ToLookup(f => f.WixFile.Directory);
+                        }
+
+                        foreach (FileFacade facade in filesByDirectory[row.Id])
+                        {
+                            this.MergeSymbolPaths(row, deltaPatchFiles[facade.File.File]);
+                        }
+                        break;
+
+                    case SymbolPathType.Media:
+                        if (null == filesByDiskId)
+                        {
+                            filesByDiskId = facades.ToLookup(f => f.WixFile.DiskId.ToString(CultureInfo.InvariantCulture));
+                        }
+
+                        foreach (FileFacade facade in filesByDiskId[row.Id])
+                        {
+                            this.MergeSymbolPaths(row, deltaPatchFiles[facade.File.File]);
+                        }
+                        break;
+
+                    case SymbolPathType.Product:
+                        foreach (WixDeltaPatchFileRow fileRow in deltaPatchFiles.Values)
+                        {
+                            this.MergeSymbolPaths(row, fileRow);
+                        }
+                        break;
+
+                    default:
+                        // error
+                        break;
+                }
+            }
+
+            return deltaPatchFiles;
+        }
+
+        /// <summary>
+        /// Merge data from a row in the WixPatchSymbolsPaths table into an associated WixDeltaPatchFile row.
+        /// </summary>
+        /// <param name="row">Row from the WixPatchSymbolsPaths table.</param>
+        /// <param name="file">FileRow into which to set symbol information.</param>
+        /// <comment>This includes PreviousData as well.</comment>
+        private void MergeSymbolPaths(WixDeltaPatchSymbolPathsRow row, WixDeltaPatchFileRow file)
+        {
+            if (null == file.Symbols)
+            {
+                file.Symbols = row.SymbolPaths;
+            }
+            else
+            {
+                file.Symbols = String.Concat(file.Symbols, ";", row.SymbolPaths);
+            }
+
+            Field field = row.Fields[2];
+            if (null != field.PreviousData)
+            {
+                if (null == file.PreviousSymbols)
+                {
+                    file.PreviousSymbols = field.PreviousData;
+                }
+                else
+                {
+                    file.PreviousSymbols = String.Concat(file.PreviousSymbols, ";", field.PreviousData);
+                }
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/Databases/MergeModulesCommand.cs b/src/WixToolset.Core/Bind/Databases/MergeModulesCommand.cs
new file mode 100644
index 00000000..035ef059
--- /dev/null
+++ b/src/WixToolset.Core/Bind/Databases/MergeModulesCommand.cs
@@ -0,0 +1,350 @@
+// 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.Bind.Databases
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Collections.Specialized;
+    using System.ComponentModel;
+    using System.Diagnostics;
+    using System.Globalization;
+    using System.IO;
+    using System.Linq;
+    using System.Runtime.InteropServices;
+    using System.Text;
+    using System.Xml;
+    using System.Xml.XPath;
+    using WixToolset.Clr.Interop;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+    using WixToolset.MergeMod;
+    using WixToolset.Msi;
+    using WixToolset.Core.Native;
+
+    /// <summary>
+    /// Update file information.
+    /// </summary>
+    internal class MergeModulesCommand : ICommand
+    {
+        public IEnumerable<FileFacade> FileFacades { private get; set; }
+
+        public Output Output { private get; set; }
+
+        public string OutputPath { private get; set; }
+
+        public IEnumerable<string> SuppressedTableNames { private get; set; }
+
+        public string TempFilesLocation { private get; set; }
+
+        public void Execute()
+        {
+            Debug.Assert(OutputType.Product == this.Output.Type);
+
+            Table wixMergeTable = this.Output.Tables["WixMerge"];
+            Table wixFeatureModulesTable = this.Output.Tables["WixFeatureModules"];
+
+            // check for merge rows to see if there is any work to do
+            if (null == wixMergeTable || 0 == wixMergeTable.Rows.Count)
+            {
+                return;
+            }
+
+            IMsmMerge2 merge = null;
+            bool commit = true;
+            bool logOpen = false;
+            bool databaseOpen = false;
+            string logPath = null;
+            try
+            {
+                merge = MsmInterop.GetMsmMerge();
+
+                logPath = Path.Combine(this.TempFilesLocation, "merge.log");
+                merge.OpenLog(logPath);
+                logOpen = true;
+
+                merge.OpenDatabase(this.OutputPath);
+                databaseOpen = true;
+
+                // process all the merge rows
+                foreach (WixMergeRow wixMergeRow in wixMergeTable.Rows)
+                {
+                    bool moduleOpen = false;
+
+                    try
+                    {
+                        short mergeLanguage;
+
+                        try
+                        {
+                            mergeLanguage = Convert.ToInt16(wixMergeRow.Language, CultureInfo.InvariantCulture);
+                        }
+                        catch (System.FormatException)
+                        {
+                            Messaging.Instance.OnMessage(WixErrors.InvalidMergeLanguage(wixMergeRow.SourceLineNumbers, wixMergeRow.Id, wixMergeRow.Language));
+                            continue;
+                        }
+
+                        Messaging.Instance.OnMessage(WixVerboses.OpeningMergeModule(wixMergeRow.SourceFile, mergeLanguage));
+                        merge.OpenModule(wixMergeRow.SourceFile, mergeLanguage);
+                        moduleOpen = true;
+
+                        // If there is merge configuration data, create a callback object to contain it all.
+                        ConfigurationCallback callback = null;
+                        if (!String.IsNullOrEmpty(wixMergeRow.ConfigurationData))
+                        {
+                            callback = new ConfigurationCallback(wixMergeRow.ConfigurationData);
+                        }
+
+                        // merge the module into the database that's being built
+                        Messaging.Instance.OnMessage(WixVerboses.MergingMergeModule(wixMergeRow.SourceFile));
+                        merge.MergeEx(wixMergeRow.Feature, wixMergeRow.Directory, callback);
+
+                        // connect any non-primary features
+                        if (null != wixFeatureModulesTable)
+                        {
+                            foreach (Row row in wixFeatureModulesTable.Rows)
+                            {
+                                if (wixMergeRow.Id == (string)row[1])
+                                {
+                                    Messaging.Instance.OnMessage(WixVerboses.ConnectingMergeModule(wixMergeRow.SourceFile, (string)row[0]));
+                                    merge.Connect((string)row[0]);
+                                }
+                            }
+                        }
+                    }
+                    catch (COMException)
+                    {
+                        commit = false;
+                    }
+                    finally
+                    {
+                        IMsmErrors mergeErrors = merge.Errors;
+
+                        // display all the errors encountered during the merge operations for this module
+                        for (int i = 1; i <= mergeErrors.Count; i++)
+                        {
+                            IMsmError mergeError = mergeErrors[i];
+                            StringBuilder databaseKeys = new StringBuilder();
+                            StringBuilder moduleKeys = new StringBuilder();
+
+                            // build a string of the database keys
+                            for (int j = 1; j <= mergeError.DatabaseKeys.Count; j++)
+                            {
+                                if (1 != j)
+                                {
+                                    databaseKeys.Append(';');
+                                }
+                                databaseKeys.Append(mergeError.DatabaseKeys[j]);
+                            }
+
+                            // build a string of the module keys
+                            for (int j = 1; j <= mergeError.ModuleKeys.Count; j++)
+                            {
+                                if (1 != j)
+                                {
+                                    moduleKeys.Append(';');
+                                }
+                                moduleKeys.Append(mergeError.ModuleKeys[j]);
+                            }
+
+                            // display the merge error based on the msm error type
+                            switch (mergeError.Type)
+                            {
+                                case MsmErrorType.msmErrorExclusion:
+                                    Messaging.Instance.OnMessage(WixErrors.MergeExcludedModule(wixMergeRow.SourceLineNumbers, wixMergeRow.Id, moduleKeys.ToString()));
+                                    break;
+                                case MsmErrorType.msmErrorFeatureRequired:
+                                    Messaging.Instance.OnMessage(WixErrors.MergeFeatureRequired(wixMergeRow.SourceLineNumbers, mergeError.ModuleTable, moduleKeys.ToString(), wixMergeRow.SourceFile, wixMergeRow.Id));
+                                    break;
+                                case MsmErrorType.msmErrorLanguageFailed:
+                                    Messaging.Instance.OnMessage(WixErrors.MergeLanguageFailed(wixMergeRow.SourceLineNumbers, mergeError.Language, wixMergeRow.SourceFile));
+                                    break;
+                                case MsmErrorType.msmErrorLanguageUnsupported:
+                                    Messaging.Instance.OnMessage(WixErrors.MergeLanguageUnsupported(wixMergeRow.SourceLineNumbers, mergeError.Language, wixMergeRow.SourceFile));
+                                    break;
+                                case MsmErrorType.msmErrorResequenceMerge:
+                                    Messaging.Instance.OnMessage(WixWarnings.MergeRescheduledAction(wixMergeRow.SourceLineNumbers, mergeError.DatabaseTable, databaseKeys.ToString(), wixMergeRow.SourceFile));
+                                    break;
+                                case MsmErrorType.msmErrorTableMerge:
+                                    if ("_Validation" != mergeError.DatabaseTable) // ignore merge errors in the _Validation table
+                                    {
+                                        Messaging.Instance.OnMessage(WixWarnings.MergeTableFailed(wixMergeRow.SourceLineNumbers, mergeError.DatabaseTable, databaseKeys.ToString(), wixMergeRow.SourceFile));
+                                    }
+                                    break;
+                                case MsmErrorType.msmErrorPlatformMismatch:
+                                    Messaging.Instance.OnMessage(WixErrors.MergePlatformMismatch(wixMergeRow.SourceLineNumbers, wixMergeRow.SourceFile));
+                                    break;
+                                default:
+                                    Messaging.Instance.OnMessage(WixErrors.UnexpectedException(String.Format(CultureInfo.CurrentUICulture, WixStrings.EXP_UnexpectedMergerErrorWithType, Enum.GetName(typeof(MsmErrorType), mergeError.Type), logPath), "InvalidOperationException", Environment.StackTrace));
+                                    break;
+                            }
+                        }
+
+                        if (0 >= mergeErrors.Count && !commit)
+                        {
+                            Messaging.Instance.OnMessage(WixErrors.UnexpectedException(String.Format(CultureInfo.CurrentUICulture, WixStrings.EXP_UnexpectedMergerErrorInSourceFile, wixMergeRow.SourceFile, logPath), "InvalidOperationException", Environment.StackTrace));
+                        }
+
+                        if (moduleOpen)
+                        {
+                            merge.CloseModule();
+                        }
+                    }
+                }
+            }
+            finally
+            {
+                if (databaseOpen)
+                {
+                    merge.CloseDatabase(commit);
+                }
+
+                if (logOpen)
+                {
+                    merge.CloseLog();
+                }
+            }
+
+            // stop processing if an error previously occurred
+            if (Messaging.Instance.EncounteredError)
+            {
+                return;
+            }
+
+            using (Database db = new Database(this.OutputPath, OpenDatabase.Direct))
+            {
+                Table suppressActionTable = this.Output.Tables["WixSuppressAction"];
+
+                // suppress individual actions
+                if (null != suppressActionTable)
+                {
+                    foreach (Row row in suppressActionTable.Rows)
+                    {
+                        if (db.TableExists((string)row[0]))
+                        {
+                            string query = String.Format(CultureInfo.InvariantCulture, "SELECT * FROM {0} WHERE `Action` = '{1}'", row[0].ToString(), (string)row[1]);
+
+                            using (View view = db.OpenExecuteView(query))
+                            {
+                                using (Record record = view.Fetch())
+                                {
+                                    if (null != record)
+                                    {
+                                        Messaging.Instance.OnMessage(WixWarnings.SuppressMergedAction((string)row[1], row[0].ToString()));
+                                        view.Modify(ModifyView.Delete, record);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                // query for merge module actions in suppressed sequences and drop them
+                foreach (string tableName in this.SuppressedTableNames)
+                {
+                    if (!db.TableExists(tableName))
+                    {
+                        continue;
+                    }
+
+                    using (View view = db.OpenExecuteView(String.Concat("SELECT `Action` FROM ", tableName)))
+                    {
+                        while (true)
+                        {
+                            using (Record resultRecord = view.Fetch())
+                            {
+                                if (null == resultRecord)
+                                {
+                                    break;
+                                }
+
+                                Messaging.Instance.OnMessage(WixWarnings.SuppressMergedAction(resultRecord.GetString(1), tableName));
+                            }
+                        }
+                    }
+
+                    // drop suppressed sequences
+                    using (View view = db.OpenExecuteView(String.Concat("DROP TABLE ", tableName)))
+                    {
+                    }
+
+                    // delete the validation rows
+                    using (View view = db.OpenView(String.Concat("DELETE FROM _Validation WHERE `Table` = ?")))
+                    {
+                        using (Record record = new Record(1))
+                        {
+                            record.SetString(1, tableName);
+                            view.Execute(record);
+                        }
+                    }
+                }
+
+                // now update the Attributes column for the files from the Merge Modules
+                Messaging.Instance.OnMessage(WixVerboses.ResequencingMergeModuleFiles());
+                using (View view = db.OpenView("SELECT `Sequence`, `Attributes` FROM `File` WHERE `File`=?"))
+                {
+                    foreach (FileFacade file in this.FileFacades)
+                    {
+                        if (!file.FromModule)
+                        {
+                            continue;
+                        }
+
+                        using (Record record = new Record(1))
+                        {
+                            record.SetString(1, file.File.File);
+                            view.Execute(record);
+                        }
+
+                        using (Record recordUpdate = view.Fetch())
+                        {
+                            if (null == recordUpdate)
+                            {
+                                throw new InvalidOperationException("Failed to fetch a File row from the database that was merged in from a module.");
+                            }
+
+                            recordUpdate.SetInteger(1, file.File.Sequence);
+
+                            // update the file attributes to match the compression specified
+                            // on the Merge element or on the Package element
+                            int attributes = 0;
+
+                            // get the current value if its not null
+                            if (!recordUpdate.IsNull(2))
+                            {
+                                attributes = recordUpdate.GetInteger(2);
+                            }
+
+                            if (YesNoType.Yes == file.File.Compressed)
+                            {
+                                // these are mutually exclusive
+                                attributes |= MsiInterop.MsidbFileAttributesCompressed;
+                                attributes &= ~MsiInterop.MsidbFileAttributesNoncompressed;
+                            }
+                            else if (YesNoType.No == file.File.Compressed)
+                            {
+                                // these are mutually exclusive
+                                attributes |= MsiInterop.MsidbFileAttributesNoncompressed;
+                                attributes &= ~MsiInterop.MsidbFileAttributesCompressed;
+                            }
+                            else // not specified
+                            {
+                                Debug.Assert(YesNoType.NotSet == file.File.Compressed);
+
+                                // clear any compression bits
+                                attributes &= ~MsiInterop.MsidbFileAttributesCompressed;
+                                attributes &= ~MsiInterop.MsidbFileAttributesNoncompressed;
+                            }
+
+                            recordUpdate.SetInteger(2, attributes);
+
+                            view.Modify(ModifyView.Update, recordUpdate);
+                        }
+                    }
+                }
+
+                db.Commit();
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/Databases/ProcessUncompressedFilesCommand.cs b/src/WixToolset.Core/Bind/Databases/ProcessUncompressedFilesCommand.cs
new file mode 100644
index 00000000..dd7b85b7
--- /dev/null
+++ b/src/WixToolset.Core/Bind/Databases/ProcessUncompressedFilesCommand.cs
@@ -0,0 +1,115 @@
+// 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.Bind.Databases
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.IO;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+    using WixToolset.Msi;
+    using WixToolset.Core.Native;
+
+    /// <summary>
+    /// Defines the file transfers necessary to layout the uncompressed files.
+    /// </summary>
+    internal class ProcessUncompressedFilesCommand : ICommand
+    {
+        public string DatabasePath { private get; set; }
+
+        public IEnumerable<FileFacade> FileFacades { private get; set; }
+
+        public RowDictionary<MediaRow> MediaRows { private get; set; }
+
+        public string LayoutDirectory { private get; set; }
+
+        public bool Compressed { private get; set; }
+
+        public bool LongNamesInImage { private get; set; }
+
+        public Func<MediaRow, string, string, string> ResolveMedia { private get; set; }
+
+        public Table WixMediaTable { private get; set; }
+
+        public IEnumerable<FileTransfer> FileTransfers { get; private set; }
+
+        public void Execute()
+        {
+            List<FileTransfer> fileTransfers = new List<FileTransfer>();
+
+            Hashtable directories = new Hashtable();
+
+            RowDictionary<WixMediaRow> wixMediaRows = new RowDictionary<WixMediaRow>(this.WixMediaTable);
+
+            using (Database db = new Database(this.DatabasePath, OpenDatabase.ReadOnly))
+            {
+                using (View directoryView = db.OpenExecuteView("SELECT `Directory`, `Directory_Parent`, `DefaultDir` FROM `Directory`"))
+                {
+                    while (true)
+                    {
+                        using (Record directoryRecord = directoryView.Fetch())
+                        {
+                            if (null == directoryRecord)
+                            {
+                                break;
+                            }
+
+                            string sourceName = Installer.GetName(directoryRecord.GetString(3), true, this.LongNamesInImage);
+
+                            directories.Add(directoryRecord.GetString(1), new ResolvedDirectory(directoryRecord.GetString(2), sourceName));
+                        }
+                    }
+                }
+
+                using (View fileView = db.OpenView("SELECT `Directory_`, `FileName` FROM `Component`, `File` WHERE `Component`.`Component`=`File`.`Component_` AND `File`.`File`=?"))
+                {
+                    using (Record fileQueryRecord = new Record(1))
+                    {
+                        // for each file in the array of uncompressed files
+                        foreach (FileFacade facade in this.FileFacades)
+                        {
+                            MediaRow mediaRow = this.MediaRows.Get(facade.WixFile.DiskId);
+                            string relativeFileLayoutPath = null;
+
+                            WixMediaRow wixMediaRow = null;
+                            string mediaLayoutFolder = null;
+
+                            if (wixMediaRows.TryGetValue(mediaRow.GetKey(), out wixMediaRow))
+                            {
+                                mediaLayoutFolder = wixMediaRow.Layout;
+                            }
+
+                            string mediaLayoutDirectory = this.ResolveMedia(mediaRow, mediaLayoutFolder, this.LayoutDirectory);
+
+                            // setup up the query record and find the appropriate file in the
+                            // previously executed file view
+                            fileQueryRecord[1] = facade.File.File;
+                            fileView.Execute(fileQueryRecord);
+
+                            using (Record fileRecord = fileView.Fetch())
+                            {
+                                if (null == fileRecord)
+                                {
+                                    throw new WixException(WixErrors.FileIdentifierNotFound(facade.File.SourceLineNumbers, facade.File.File));
+                                }
+
+                                relativeFileLayoutPath = Binder.GetFileSourcePath(directories, fileRecord[1], fileRecord[2], this.Compressed, this.LongNamesInImage);
+                            }
+
+                            // finally put together the base media layout path and the relative file layout path
+                            string fileLayoutPath = Path.Combine(mediaLayoutDirectory, relativeFileLayoutPath);
+                            FileTransfer transfer;
+                            if (FileTransfer.TryCreate(facade.WixFile.Source, fileLayoutPath, false, "File", facade.File.SourceLineNumbers, out transfer))
+                            {
+                                fileTransfers.Add(transfer);
+                            }
+                        }
+                    }
+                }
+            }
+
+            this.FileTransfers = fileTransfers;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/Databases/UpdateControlTextCommand.cs b/src/WixToolset.Core/Bind/Databases/UpdateControlTextCommand.cs
new file mode 100644
index 00000000..9e17ee02
--- /dev/null
+++ b/src/WixToolset.Core/Bind/Databases/UpdateControlTextCommand.cs
@@ -0,0 +1,80 @@
+// 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.Bind.Databases
+{
+    using System;
+    using System.IO;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+
+    internal class UpdateControlTextCommand : ICommand
+    {
+        public Table BBControlTable { private get; set; }
+
+        public Table WixBBControlTable { private get; set; }
+
+        public Table ControlTable { private get; set; }
+
+        public Table WixControlTable { private get; set; }
+
+        public void Execute()
+        {
+            if (null != this.WixBBControlTable)
+            {
+                RowDictionary<BBControlRow> bbControlRows = new RowDictionary<BBControlRow>(this.BBControlTable);
+                foreach (Row wixRow in this.WixBBControlTable.Rows)
+                {
+                    BBControlRow bbControlRow = bbControlRows.Get(wixRow.GetPrimaryKey());
+                    bbControlRow.Text = this.ReadTextFile(bbControlRow.SourceLineNumbers, wixRow.FieldAsString(2));
+                }
+            }
+
+            if (null != this.WixControlTable)
+            {
+                RowDictionary<ControlRow> controlRows = new RowDictionary<ControlRow>(this.ControlTable);
+                foreach (Row wixRow in this.WixControlTable.Rows)
+                {
+                    ControlRow controlRow = controlRows.Get(wixRow.GetPrimaryKey());
+                    controlRow.Text = this.ReadTextFile(controlRow.SourceLineNumbers, wixRow.FieldAsString(2));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Reads a text file and returns the contents.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line numbers for row from source.</param>
+        /// <param name="source">Source path to file to read.</param>
+        /// <returns>Text string read from file.</returns>
+        private string ReadTextFile(SourceLineNumber sourceLineNumbers, string source)
+        {
+            string text = null;
+
+            try
+            {
+                using (StreamReader reader = new StreamReader(source))
+                {
+                    text = reader.ReadToEnd();
+                }
+            }
+            catch (DirectoryNotFoundException e)
+            {
+                Messaging.Instance.OnMessage(WixErrors.BinderFileManagerMissingFile(sourceLineNumbers, e.Message));
+            }
+            catch (FileNotFoundException e)
+            {
+                Messaging.Instance.OnMessage(WixErrors.BinderFileManagerMissingFile(sourceLineNumbers, e.Message));
+            }
+            catch (IOException e)
+            {
+                Messaging.Instance.OnMessage(WixErrors.BinderFileManagerMissingFile(sourceLineNumbers, e.Message));
+            }
+            catch (NotSupportedException)
+            {
+                Messaging.Instance.OnMessage(WixErrors.FileNotFound(sourceLineNumbers, source));
+            }
+
+            return text;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/Databases/UpdateFileFacadesCommand.cs b/src/WixToolset.Core/Bind/Databases/UpdateFileFacadesCommand.cs
new file mode 100644
index 00000000..36818afa
--- /dev/null
+++ b/src/WixToolset.Core/Bind/Databases/UpdateFileFacadesCommand.cs
@@ -0,0 +1,532 @@
+// 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.Bind.Databases
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Collections.Specialized;
+    using System.ComponentModel;
+    using System.Globalization;
+    using System.IO;
+    using System.Linq;
+    using System.Xml;
+    using System.Xml.XPath;
+    using WixToolset.Clr.Interop;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+    using WixToolset.Msi;
+
+    /// <summary>
+    /// Update file information.
+    /// </summary>
+    internal class UpdateFileFacadesCommand : ICommand
+    {
+        public IEnumerable<FileFacade> FileFacades { private get; set; }
+
+        public IEnumerable<FileFacade> UpdateFileFacades { private get; set; }
+
+        public string ModularizationGuid { private get; set; }
+
+        public Output Output { private get; set; }
+
+        public bool OverwriteHash { private get; set; }
+
+        public TableDefinitionCollection TableDefinitions { private get; set; }
+
+        public IDictionary<string, string> VariableCache { private get; set; }
+
+        public void Execute()
+        {
+            foreach (FileFacade file in this.UpdateFileFacades)
+            {
+                this.UpdateFileFacade(file);
+            }
+        }
+
+        private void UpdateFileFacade(FileFacade file)
+        {
+            FileInfo fileInfo = null;
+            try
+            {
+                fileInfo = new FileInfo(file.WixFile.Source);
+            }
+            catch (ArgumentException)
+            {
+                Messaging.Instance.OnMessage(WixErrors.InvalidFileName(file.File.SourceLineNumbers, file.WixFile.Source));
+                return;
+            }
+            catch (PathTooLongException)
+            {
+                Messaging.Instance.OnMessage(WixErrors.InvalidFileName(file.File.SourceLineNumbers, file.WixFile.Source));
+                return;
+            }
+            catch (NotSupportedException)
+            {
+                Messaging.Instance.OnMessage(WixErrors.InvalidFileName(file.File.SourceLineNumbers, file.WixFile.Source));
+                return;
+            }
+
+            if (!fileInfo.Exists)
+            {
+                Messaging.Instance.OnMessage(WixErrors.CannotFindFile(file.File.SourceLineNumbers, file.File.File, file.File.FileName, file.WixFile.Source));
+                return;
+            }
+
+            using (FileStream fileStream = new FileStream(fileInfo.FullName, FileMode.Open, FileAccess.Read, FileShare.Read))
+            {
+                if (Int32.MaxValue < fileStream.Length)
+                {
+                    throw new WixException(WixErrors.FileTooLarge(file.File.SourceLineNumbers, file.WixFile.Source));
+                }
+
+                file.File.FileSize = Convert.ToInt32(fileStream.Length, CultureInfo.InvariantCulture);
+            }
+
+            string version = null;
+            string language = null;
+            try
+            {
+                Installer.GetFileVersion(fileInfo.FullName, out version, out language);
+            }
+            catch (Win32Exception e)
+            {
+                if (0x2 == e.NativeErrorCode) // ERROR_FILE_NOT_FOUND
+                {
+                    throw new WixException(WixErrors.FileNotFound(file.File.SourceLineNumbers, fileInfo.FullName));
+                }
+                else
+                {
+                    throw new WixException(WixErrors.Win32Exception(e.NativeErrorCode, e.Message));
+                }
+            }
+
+            // If there is no version, it is assumed there is no language because it won't matter in the versioning of the install.
+            if (String.IsNullOrEmpty(version)) // unversioned files have their hashes added to the MsiFileHash table
+            {
+                if (!this.OverwriteHash)
+                {
+                    // not overwriting hash, so don't do the rest of these options.
+                }
+                else if (null != file.File.Version)
+                {
+                    // Search all of the file rows available to see if the specified version is actually a companion file. Yes, this looks
+                    // very expensive and you're probably thinking it would be better to create an index of some sort to do an O(1) look up.
+                    // That's a reasonable thought but companion file usage is usually pretty rare so we'd be doing something expensive (indexing
+                    // all the file rows) for a relatively uncommon situation. Let's not do that.
+                    //
+                    // Also, if we do not find a matching file identifier then the user provided a default version and is providing a version
+                    // for unversioned file. That's allowed but generally a dangerous thing to do so let's point that out to the user.
+                    if (!this.FileFacades.Any(r => file.File.Version.Equals(r.File.File, StringComparison.Ordinal)))
+                    {
+                        Messaging.Instance.OnMessage(WixWarnings.DefaultVersionUsedForUnversionedFile(file.File.SourceLineNumbers, file.File.Version, file.File.File));
+                    }
+                }
+                else
+                {
+                    if (null != file.File.Language)
+                    {
+                        Messaging.Instance.OnMessage(WixWarnings.DefaultLanguageUsedForUnversionedFile(file.File.SourceLineNumbers, file.File.Language, file.File.File));
+                    }
+
+                    int[] hash;
+                    try
+                    {
+                        Installer.GetFileHash(fileInfo.FullName, 0, out hash);
+                    }
+                    catch (Win32Exception e)
+                    {
+                        if (0x2 == e.NativeErrorCode) // ERROR_FILE_NOT_FOUND
+                        {
+                            throw new WixException(WixErrors.FileNotFound(file.File.SourceLineNumbers, fileInfo.FullName));
+                        }
+                        else
+                        {
+                            throw new WixException(WixErrors.Win32Exception(e.NativeErrorCode, fileInfo.FullName, e.Message));
+                        }
+                    }
+
+                    if (null == file.Hash)
+                    {
+                        Table msiFileHashTable = this.Output.EnsureTable(this.TableDefinitions["MsiFileHash"]);
+                        file.Hash = msiFileHashTable.CreateRow(file.File.SourceLineNumbers);
+                    }
+
+                    file.Hash[0] = file.File.File;
+                    file.Hash[1] = 0;
+                    file.Hash[2] = hash[0];
+                    file.Hash[3] = hash[1];
+                    file.Hash[4] = hash[2];
+                    file.Hash[5] = hash[3];
+                }
+            }
+            else // update the file row with the version and language information.
+            {
+                // If no version was provided by the user, use the version from the file itself.
+                // This is the most common case.
+                if (String.IsNullOrEmpty(file.File.Version))
+                {
+                    file.File.Version = version;
+                }
+                else if (!this.FileFacades.Any(r => file.File.Version.Equals(r.File.File, StringComparison.Ordinal))) // this looks expensive, but see explanation below.
+                {
+                    // The user provided a default version for the file row so we looked for a companion file (a file row with Id matching
+                    // the version value). We didn't find it so, we will override the default version they provided with the actual
+                    // version from the file itself. Now, I know it looks expensive to search through all the file rows trying to match
+                    // on the Id. However, the alternative is to build a big index of all file rows to do look ups. Since this case
+                    // where the file version is already present is rare (companion files are pretty uncommon), we'll do the more
+                    // CPU intensive search to save on the memory intensive index that wouldn't be used much.
+                    //
+                    // Also note this case can occur when the file is being updated using the WixBindUpdatedFiles extension mechanism.
+                    // That's typically even more rare than companion files so again, no index, just search.
+                    file.File.Version = version;
+                }
+
+                if (!String.IsNullOrEmpty(file.File.Language) && String.IsNullOrEmpty(language))
+                {
+                    Messaging.Instance.OnMessage(WixWarnings.DefaultLanguageUsedForVersionedFile(file.File.SourceLineNumbers, file.File.Language, file.File.File));
+                }
+                else // override the default provided by the user (usually nothing) with the actual language from the file itself.
+                {
+                    file.File.Language = language;
+                }
+
+                // Populate the binder variables for this file information if requested.
+                if (null != this.VariableCache)
+                {
+                    if (!String.IsNullOrEmpty(file.File.Version))
+                    {
+                        string key = String.Format(CultureInfo.InvariantCulture, "fileversion.{0}", BindDatabaseCommand.Demodularize(this.Output.Type, this.ModularizationGuid, file.File.File));
+                        this.VariableCache[key] = file.File.Version;
+                    }
+
+                    if (!String.IsNullOrEmpty(file.File.Language))
+                    {
+                        string key = String.Format(CultureInfo.InvariantCulture, "filelanguage.{0}", BindDatabaseCommand.Demodularize(this.Output.Type, ModularizationGuid, file.File.File));
+                        this.VariableCache[key] = file.File.Language;
+                    }
+                }
+            }
+
+            // If this is a CLR assembly, load the assembly and get the assembly name information
+            if (FileAssemblyType.DotNetAssembly == file.WixFile.AssemblyType)
+            {
+                bool targetNetfx1 = false;
+                StringDictionary assemblyNameValues = new StringDictionary();
+
+                ClrInterop.IReferenceIdentity referenceIdentity = null;
+                Guid referenceIdentityGuid = ClrInterop.ReferenceIdentityGuid;
+                uint result = ClrInterop.GetAssemblyIdentityFromFile(fileInfo.FullName, ref referenceIdentityGuid, out referenceIdentity);
+                if (0 == result && null != referenceIdentity)
+                {
+                    string imageRuntimeVersion = referenceIdentity.GetAttribute(null, "ImageRuntimeVersion");
+                    if (null != imageRuntimeVersion)
+                    {
+                        targetNetfx1 = imageRuntimeVersion.StartsWith("v1", StringComparison.OrdinalIgnoreCase);
+                    }
+
+                    string culture = referenceIdentity.GetAttribute(null, "Culture") ?? "neutral";
+                    assemblyNameValues.Add("Culture", culture);
+
+                    string name = referenceIdentity.GetAttribute(null, "Name");
+                    if (null != name)
+                    {
+                        assemblyNameValues.Add("Name", name);
+                    }
+
+                    string processorArchitecture = referenceIdentity.GetAttribute(null, "ProcessorArchitecture");
+                    if (null != processorArchitecture)
+                    {
+                        assemblyNameValues.Add("ProcessorArchitecture", processorArchitecture);
+                    }
+
+                    string publicKeyToken = referenceIdentity.GetAttribute(null, "PublicKeyToken");
+                    if (null != publicKeyToken)
+                    {
+                        bool publicKeyIsNeutral = (String.Equals(publicKeyToken, "neutral", StringComparison.OrdinalIgnoreCase));
+
+                        // Managed code expects "null" instead of "neutral", and
+                        // this won't be installed to the GAC since it's not signed anyway.
+                        assemblyNameValues.Add("publicKeyToken", publicKeyIsNeutral ? "null" : publicKeyToken.ToUpperInvariant());
+                        assemblyNameValues.Add("publicKeyTokenPreservedCase", publicKeyIsNeutral ? "null" : publicKeyToken);
+                    }
+                    else if (file.WixFile.AssemblyApplication == null)
+                    {
+                        throw new WixException(WixErrors.GacAssemblyNoStrongName(file.File.SourceLineNumbers, fileInfo.FullName, file.File.Component));
+                    }
+
+                    string assemblyVersion = referenceIdentity.GetAttribute(null, "Version");
+                    if (null != version)
+                    {
+                        assemblyNameValues.Add("Version", assemblyVersion);
+                    }
+                }
+                else
+                {
+                    Messaging.Instance.OnMessage(WixErrors.InvalidAssemblyFile(file.File.SourceLineNumbers, fileInfo.FullName, String.Format(CultureInfo.InvariantCulture, "HRESULT: 0x{0:x8}", result)));
+                    return;
+                }
+
+                Table assemblyNameTable = this.Output.EnsureTable(this.TableDefinitions["MsiAssemblyName"]);
+                if (assemblyNameValues.ContainsKey("name"))
+                {
+                    this.SetMsiAssemblyName(assemblyNameTable, file, "name", assemblyNameValues["name"]);
+                }
+
+                if (!String.IsNullOrEmpty(version))
+                {
+                    this.SetMsiAssemblyName(assemblyNameTable, file, "fileVersion", version);
+                }
+
+                if (assemblyNameValues.ContainsKey("version"))
+                {
+                    string assemblyVersion = assemblyNameValues["version"];
+
+                    if (!targetNetfx1)
+                    {
+                        // There is a bug in v1 fusion that requires the assembly's "version" attribute
+                        // to be equal to or longer than the "fileVersion" in length when its present;
+                        // the workaround is to prepend zeroes to the last version number in the assembly
+                        // version.
+                        if (null != version && version.Length > assemblyVersion.Length)
+                        {
+                            string padding = new string('0', version.Length - assemblyVersion.Length);
+                            string[] assemblyVersionNumbers = assemblyVersion.Split('.');
+
+                            if (assemblyVersionNumbers.Length > 0)
+                            {
+                                assemblyVersionNumbers[assemblyVersionNumbers.Length - 1] = String.Concat(padding, assemblyVersionNumbers[assemblyVersionNumbers.Length - 1]);
+                                assemblyVersion = String.Join(".", assemblyVersionNumbers);
+                            }
+                        }
+                    }
+
+                    this.SetMsiAssemblyName(assemblyNameTable, file, "version", assemblyVersion);
+                }
+
+                if (assemblyNameValues.ContainsKey("culture"))
+                {
+                    this.SetMsiAssemblyName(assemblyNameTable, file, "culture", assemblyNameValues["culture"]);
+                }
+
+                if (assemblyNameValues.ContainsKey("publicKeyToken"))
+                {
+                    this.SetMsiAssemblyName(assemblyNameTable, file, "publicKeyToken", assemblyNameValues["publicKeyToken"]);
+                }
+
+                if (!String.IsNullOrEmpty(file.WixFile.ProcessorArchitecture))
+                {
+                    this.SetMsiAssemblyName(assemblyNameTable, file, "processorArchitecture", file.WixFile.ProcessorArchitecture);
+                }
+
+                if (assemblyNameValues.ContainsKey("processorArchitecture"))
+                {
+                    this.SetMsiAssemblyName(assemblyNameTable, file, "processorArchitecture", assemblyNameValues["processorArchitecture"]);
+                }
+
+                // add the assembly name to the information cache
+                if (null != this.VariableCache)
+                {
+                    string fileId = BindDatabaseCommand.Demodularize(this.Output.Type, this.ModularizationGuid, file.File.File);
+                    string key = String.Concat("assemblyfullname.", fileId);
+                    string assemblyName = String.Concat(assemblyNameValues["name"], ", version=", assemblyNameValues["version"], ", culture=", assemblyNameValues["culture"], ", publicKeyToken=", String.IsNullOrEmpty(assemblyNameValues["publicKeyToken"]) ? "null" : assemblyNameValues["publicKeyToken"]);
+                    if (assemblyNameValues.ContainsKey("processorArchitecture"))
+                    {
+                        assemblyName = String.Concat(assemblyName, ", processorArchitecture=", assemblyNameValues["processorArchitecture"]);
+                    }
+
+                    this.VariableCache[key] = assemblyName;
+
+                    // Add entries with the preserved case publicKeyToken
+                    string pcAssemblyNameKey = String.Concat("assemblyfullnamepreservedcase.", fileId);
+                    this.VariableCache[pcAssemblyNameKey] = (assemblyNameValues["publicKeyToken"] == assemblyNameValues["publicKeyTokenPreservedCase"]) ? assemblyName : assemblyName.Replace(assemblyNameValues["publicKeyToken"], assemblyNameValues["publicKeyTokenPreservedCase"]);
+
+                    string pcPublicKeyTokenKey = String.Concat("assemblypublickeytokenpreservedcase.", fileId);
+                    this.VariableCache[pcPublicKeyTokenKey] = assemblyNameValues["publicKeyTokenPreservedCase"];
+                }
+            }
+            else if (FileAssemblyType.Win32Assembly == file.WixFile.AssemblyType)
+            {
+                // TODO: Consider passing in the this.FileFacades as an indexed collection instead of searching through
+                // all files like this. Even though this is a rare case it looks like we might be able to index the
+                // file earlier.
+                FileFacade fileManifest = this.FileFacades.SingleOrDefault(r => r.File.File.Equals(file.WixFile.AssemblyManifest, StringComparison.Ordinal));
+                if (null == fileManifest)
+                {
+                    Messaging.Instance.OnMessage(WixErrors.MissingManifestForWin32Assembly(file.File.SourceLineNumbers, file.File.File, file.WixFile.AssemblyManifest));
+                }
+
+                string win32Type = null;
+                string win32Name = null;
+                string win32Version = null;
+                string win32ProcessorArchitecture = null;
+                string win32PublicKeyToken = null;
+
+                // loading the dom is expensive we want more performant APIs than the DOM
+                // Navigator is cheaper than dom.  Perhaps there is a cheaper API still.
+                try
+                {
+                    XPathDocument doc = new XPathDocument(fileManifest.WixFile.Source);
+                    XPathNavigator nav = doc.CreateNavigator();
+                    nav.MoveToRoot();
+
+                    // this assumes a particular schema for a win32 manifest and does not
+                    // provide error checking if the file does not conform to schema.
+                    // The fallback case here is that nothing is added to the MsiAssemblyName
+                    // table for an out of tolerance Win32 manifest.  Perhaps warnings needed.
+                    if (nav.MoveToFirstChild())
+                    {
+                        while (nav.NodeType != XPathNodeType.Element || nav.Name != "assembly")
+                        {
+                            nav.MoveToNext();
+                        }
+
+                        if (nav.MoveToFirstChild())
+                        {
+                            bool hasNextSibling = true;
+                            while (nav.NodeType != XPathNodeType.Element || nav.Name != "assemblyIdentity" && hasNextSibling)
+                            {
+                                hasNextSibling = nav.MoveToNext();
+                            }
+                            if (!hasNextSibling)
+                            {
+                                Messaging.Instance.OnMessage(WixErrors.InvalidManifestContent(file.File.SourceLineNumbers, fileManifest.WixFile.Source));
+                                return;
+                            }
+
+                            if (nav.MoveToAttribute("type", String.Empty))
+                            {
+                                win32Type = nav.Value;
+                                nav.MoveToParent();
+                            }
+
+                            if (nav.MoveToAttribute("name", String.Empty))
+                            {
+                                win32Name = nav.Value;
+                                nav.MoveToParent();
+                            }
+
+                            if (nav.MoveToAttribute("version", String.Empty))
+                            {
+                                win32Version = nav.Value;
+                                nav.MoveToParent();
+                            }
+
+                            if (nav.MoveToAttribute("processorArchitecture", String.Empty))
+                            {
+                                win32ProcessorArchitecture = nav.Value;
+                                nav.MoveToParent();
+                            }
+
+                            if (nav.MoveToAttribute("publicKeyToken", String.Empty))
+                            {
+                                win32PublicKeyToken = nav.Value;
+                                nav.MoveToParent();
+                            }
+                        }
+                    }
+                }
+                catch (FileNotFoundException fe)
+                {
+                    Messaging.Instance.OnMessage(WixErrors.FileNotFound(new SourceLineNumber(fileManifest.WixFile.Source), fe.FileName, "AssemblyManifest"));
+                }
+                catch (XmlException xe)
+                {
+                    Messaging.Instance.OnMessage(WixErrors.InvalidXml(new SourceLineNumber(fileManifest.WixFile.Source), "manifest", xe.Message));
+                }
+
+                Table assemblyNameTable = this.Output.EnsureTable(this.TableDefinitions["MsiAssemblyName"]);
+                if (!String.IsNullOrEmpty(win32Name))
+                {
+                    this.SetMsiAssemblyName(assemblyNameTable, file, "name", win32Name);
+                }
+
+                if (!String.IsNullOrEmpty(win32Version))
+                {
+                    this.SetMsiAssemblyName(assemblyNameTable, file, "version", win32Version);
+                }
+
+                if (!String.IsNullOrEmpty(win32Type))
+                {
+                    this.SetMsiAssemblyName(assemblyNameTable, file, "type", win32Type);
+                }
+
+                if (!String.IsNullOrEmpty(win32ProcessorArchitecture))
+                {
+                    this.SetMsiAssemblyName(assemblyNameTable, file, "processorArchitecture", win32ProcessorArchitecture);
+                }
+
+                if (!String.IsNullOrEmpty(win32PublicKeyToken))
+                {
+                    this.SetMsiAssemblyName(assemblyNameTable, file, "publicKeyToken", win32PublicKeyToken);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Set an MsiAssemblyName row.  If it was directly authored, override the value, otherwise
+        /// create a new row.
+        /// </summary>
+        /// <param name="assemblyNameTable">MsiAssemblyName table.</param>
+        /// <param name="file">FileFacade containing the assembly read for the MsiAssemblyName row.</param>
+        /// <param name="name">MsiAssemblyName name.</param>
+        /// <param name="value">MsiAssemblyName value.</param>
+        private void SetMsiAssemblyName(Table assemblyNameTable, FileFacade file, string name, string value)
+        {
+            // check for null value (this can occur when grabbing the file version from an assembly without one)
+            if (String.IsNullOrEmpty(value))
+            {
+                Messaging.Instance.OnMessage(WixWarnings.NullMsiAssemblyNameValue(file.File.SourceLineNumbers, file.File.Component, name));
+            }
+            else
+            {
+                Row assemblyNameRow = null;
+
+                // override directly authored value
+                foreach (Row row in assemblyNameTable.Rows)
+                {
+                    if ((string)row[0] == file.File.Component && (string)row[1] == name)
+                    {
+                        assemblyNameRow = row;
+                        break;
+                    }
+                }
+
+                // if the assembly will be GAC'd and the name in the file table doesn't match the name in the MsiAssemblyName table, error because the install will fail.
+                if ("name" == name && FileAssemblyType.DotNetAssembly == file.WixFile.AssemblyType &&
+                    String.IsNullOrEmpty(file.WixFile.AssemblyApplication) &&
+                    !String.Equals(Path.GetFileNameWithoutExtension(file.File.LongFileName), value, StringComparison.OrdinalIgnoreCase))
+                {
+                    Messaging.Instance.OnMessage(WixErrors.GACAssemblyIdentityWarning(file.File.SourceLineNumbers, Path.GetFileNameWithoutExtension(file.File.LongFileName), value));
+                }
+
+                if (null == assemblyNameRow)
+                {
+                    assemblyNameRow = assemblyNameTable.CreateRow(file.File.SourceLineNumbers);
+                    assemblyNameRow[0] = file.File.Component;
+                    assemblyNameRow[1] = name;
+                    assemblyNameRow[2] = value;
+
+                    // put the MsiAssemblyName row in the same section as the related File row
+                    assemblyNameRow.SectionId = file.File.SectionId;
+
+                    if (null == file.AssemblyNames)
+                    {
+                        file.AssemblyNames = new List<Row>();
+                    }
+
+                    file.AssemblyNames.Add(assemblyNameRow);
+                }
+                else
+                {
+                    assemblyNameRow[2] = value;
+                }
+
+                if (this.VariableCache != null)
+                {
+                    string key = String.Format(CultureInfo.InvariantCulture, "assembly{0}.{1}", name, BindDatabaseCommand.Demodularize(this.Output.Type, this.ModularizationGuid, file.File.File)).ToLowerInvariant();
+                    this.VariableCache[key] = (string)assemblyNameRow[2];
+                }
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/DelayedField.cs b/src/WixToolset.Core/Bind/DelayedField.cs
new file mode 100644
index 00000000..181ac3e3
--- /dev/null
+++ b/src/WixToolset.Core/Bind/DelayedField.cs
@@ -0,0 +1,38 @@
+// 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.Bind
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Text;
+    using WixToolset.Data;
+
+    /// <summary>
+    /// Structure used to hold a row and field that contain binder variables, which need to be resolved
+    /// later, once the files have been resolved.
+    /// </summary>
+    internal class DelayedField
+    {
+        /// <summary>
+        /// Basic constructor for struct
+        /// </summary>
+        /// <param name="row">Row for the field.</param>
+        /// <param name="field">Field needing further resolution.</param>
+        public DelayedField(Row row, Field field)
+        {
+            this.Row = row;
+            this.Field = field;
+        }
+
+        /// <summary>
+        /// The row containing the field.
+        /// </summary>
+        public Row Row { get; private set; }
+
+        /// <summary>
+        /// The field needing further resolving.
+        /// </summary>
+        public Field Field { get; private set; }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/ExtractEmbeddedFiles.cs b/src/WixToolset.Core/Bind/ExtractEmbeddedFiles.cs
new file mode 100644
index 00000000..0ecd0096
--- /dev/null
+++ b/src/WixToolset.Core/Bind/ExtractEmbeddedFiles.cs
@@ -0,0 +1,83 @@
+// 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.Bind
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.IO;
+    using System.Linq;
+    using System.Security.Cryptography;
+    using System.Text;
+
+    /// <summary>
+    /// Internal helper class used to extract embedded files.
+    /// </summary>
+    internal sealed class ExtractEmbeddedFiles
+    {
+        private Dictionary<Uri, SortedList<int, string>> filesWithEmbeddedFiles = new Dictionary<Uri, SortedList<int, string>>();
+
+        public IEnumerable<Uri> Uris { get { return this.filesWithEmbeddedFiles.Keys; } }
+
+        /// <summary>
+        /// Adds an embedded file index to track and returns the path where the embedded file will be extracted. Duplicates will return the same extract path.
+        /// </summary>
+        /// <param name="uri">Uri to file containing the embedded files.</param>
+        /// <param name="embeddedFileIndex">Index of the embedded file to extract.</param>
+        /// <param name="tempPath">Path where temporary files should be placed.</param>
+        /// <returns>The extract path for the embedded file.</returns>
+        public string AddEmbeddedFileIndex(Uri uri, int embeddedFileIndex, string tempPath)
+        {
+            string extractPath;
+            SortedList<int, string> extracts;
+
+            // If the uri to the file that contains the embedded file does not already have embedded files
+            // being extracted, create the dictionary to track that.
+            if (!filesWithEmbeddedFiles.TryGetValue(uri, out extracts))
+            {
+                extracts = new SortedList<int, string>();
+                filesWithEmbeddedFiles.Add(uri, extracts);
+            }
+
+            // If the embedded file is not already tracked in the dictionary of extracts, add it.
+            if (!extracts.TryGetValue(embeddedFileIndex, out extractPath))
+            {
+                string localFileNameWithoutExtension = Path.GetFileNameWithoutExtension(uri.LocalPath);
+                string unique = this.HashUri(uri.AbsoluteUri);
+                string extractedName = String.Format(CultureInfo.InvariantCulture, @"{0}_{1}\{2}", localFileNameWithoutExtension, unique, embeddedFileIndex);
+
+                extractPath = Path.Combine(tempPath, extractedName);
+                extracts.Add(embeddedFileIndex, extractPath);
+            }
+
+            return extractPath;
+        }
+
+        public IEnumerable<ExtractFile> GetExtractFilesForUri(Uri uri)
+        {
+            SortedList<int, string> extracts;
+            if (!filesWithEmbeddedFiles.TryGetValue(uri, out extracts))
+            {
+                extracts = new SortedList<int, string>();
+            }
+
+            return extracts.Select(e => new ExtractFile() { EmbeddedFileIndex = e.Key, OutputPath = e.Value });
+        }
+
+        private string HashUri(string uri)
+        {
+            using (SHA1 sha1 = new SHA1CryptoServiceProvider())
+            {
+                byte[] hash = sha1.ComputeHash(Encoding.UTF8.GetBytes(uri));
+                return Convert.ToBase64String(hash).TrimEnd('=').Replace('+', '-').Replace('/', '_');
+            }
+        }
+
+        internal struct ExtractFile
+        {
+            public int EmbeddedFileIndex { get; set; }
+
+            public string OutputPath { get; set; }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/ExtractEmbeddedFilesCommand.cs b/src/WixToolset.Core/Bind/ExtractEmbeddedFilesCommand.cs
new file mode 100644
index 00000000..68bfd8d7
--- /dev/null
+++ b/src/WixToolset.Core/Bind/ExtractEmbeddedFilesCommand.cs
@@ -0,0 +1,53 @@
+// 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.Bind
+{
+    using System.IO;
+    using System.Reflection;
+    using WixToolset.Data;
+
+    internal class ExtractEmbeddedFilesCommand : ICommand
+    {
+        public ExtractEmbeddedFiles FilesWithEmbeddedFiles { private get; set; }
+
+        public void Execute()
+        {
+            foreach (var baseUri in this.FilesWithEmbeddedFiles.Uris)
+            {
+                Stream stream = null;
+                try
+                {
+                    // If the embedded files are stored in an assembly resource stream (usually
+                    // a .wixlib embedded in a WixExtension).
+                    if ("embeddedresource" == baseUri.Scheme)
+                    {
+                        string assemblyPath = Path.GetFullPath(baseUri.LocalPath);
+                        string resourceName = baseUri.Fragment.TrimStart('#');
+
+                        Assembly assembly = Assembly.LoadFile(assemblyPath);
+                        stream = assembly.GetManifestResourceStream(resourceName);
+                    }
+                    else // normal file (usually a binary .wixlib on disk).
+                    {
+                        stream = File.OpenRead(baseUri.LocalPath);
+                    }
+
+                    using (FileStructure fs = FileStructure.Read(stream))
+                    {
+                        foreach (var embeddedFile in this.FilesWithEmbeddedFiles.GetExtractFilesForUri(baseUri))
+                        {
+                            fs.ExtractEmbeddedFile(embeddedFile.EmbeddedFileIndex, embeddedFile.OutputPath);
+                        }
+                    }
+                }
+                finally
+                {
+                    if (null != stream)
+                    {
+                        stream.Close();
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/FileTransfer.cs b/src/WixToolset.Core/Bind/FileTransfer.cs
new file mode 100644
index 00000000..64bbc5f1
--- /dev/null
+++ b/src/WixToolset.Core/Bind/FileTransfer.cs
@@ -0,0 +1,113 @@
+// 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.Bind
+{
+    using System;
+    using System.IO;
+    using WixToolset;
+    using WixToolset.Data;
+
+    /// <summary>
+    /// Structure used for all file transfer information.
+    /// </summary>
+    internal class FileTransfer
+    {
+        /// <summary>Source path to file.</summary>
+        public string Source { get; set; }
+
+        /// <summary>Destination path for file.</summary>
+        public string Destination { get; set; }
+
+        /// <summary>Flag if file should be moved (optimal).</summary>
+        public bool Move { get; set; }
+
+        /// <summary>Optional source line numbers where this file transfer orginated.</summary>
+        public SourceLineNumber SourceLineNumbers { get; set; }
+
+        /// <summary>Optional type of file this transfer is moving or copying.</summary>
+        public string Type { get; set; }
+
+        /// <summary>Indicates whether the file transer was a built by this build or copied from other some build.</summary>
+        internal bool Built { get; set; }
+
+        /// <summary>Set during layout of media when the file transfer when the source and target resolve to the same path.</summary>
+        internal bool Redundant { get; set; }
+
+        /// <summary>
+        /// Prefer the TryCreate() method to create FileTransfer objects.
+        /// </summary>
+        /// <param name="source">Source path to file.</param>
+        /// <param name="destination">Destination path for file.</param>
+        /// <param name="move">File if file should be moved (optimal).</param>
+        /// <param name="type">Optional type of file this transfer is transferring.</param>
+        /// <param name="sourceLineNumbers">Optional source line numbers wher this transfer originated.</param>
+        public FileTransfer(string source, string destination, bool move, string type = null, SourceLineNumber sourceLineNumbers = null)
+        {
+            this.Source = source;
+            this.Destination = destination;
+            this.Move = move;
+
+            this.Type = type;
+            this.SourceLineNumbers = sourceLineNumbers;
+        }
+
+        /// <summary>
+        /// Creates a file transfer if the source and destination are different.
+        /// </summary>
+        /// <param name="source">Source path to file.</param>
+        /// <param name="destination">Destination path for file.</param>
+        /// <param name="move">File if file should be moved (optimal).</param>
+        /// <param name="type">Optional type of file this transfer is transferring.</param>
+        /// <param name="sourceLineNumbers">Optional source line numbers wher this transfer originated.</param>
+        /// <returns>true if the source and destination are the different, false if no file transfer is created.</returns>
+        public static bool TryCreate(string source, string destination, bool move, string type, SourceLineNumber sourceLineNumbers, out FileTransfer transfer)
+        {
+            string sourceFullPath = GetValidatedFullPath(sourceLineNumbers, source);
+
+            string fileLayoutFullPath = GetValidatedFullPath(sourceLineNumbers, destination);
+
+            // if the current source path (where we know that the file already exists) and the resolved
+            // path as dictated by the Directory table are not the same, then propagate the file.  The
+            // image that we create may have already been done by some other process other than the linker, so 
+            // there is no reason to copy the files to the resolved source if they are already there.
+            if (String.Equals(sourceFullPath, fileLayoutFullPath, StringComparison.OrdinalIgnoreCase))
+            {
+                transfer = null;
+                return false;
+            }
+
+            transfer = new FileTransfer(source, destination, move, type, sourceLineNumbers);
+            return true;
+        }
+
+        private static string GetValidatedFullPath(SourceLineNumber sourceLineNumbers, string path)
+        {
+            string result;
+
+            try
+            {
+                result = Path.GetFullPath(path);
+
+                string filename = Path.GetFileName(result);
+
+                foreach (string reservedName in Common.ReservedFileNames)
+                {
+                    if (reservedName.Equals(filename, StringComparison.OrdinalIgnoreCase))
+                    {
+                        throw new WixException(WixErrors.InvalidFileName(sourceLineNumbers, path));
+                    }
+                }
+            }
+            catch (System.ArgumentException)
+            {
+                throw new WixException(WixErrors.InvalidFileName(sourceLineNumbers, path));
+            }
+            catch (System.IO.PathTooLongException)
+            {
+                throw new WixException(WixErrors.PathTooLong(sourceLineNumbers, path));
+            }
+
+            return result;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/GenerateDatabaseCommand.cs b/src/WixToolset.Core/Bind/GenerateDatabaseCommand.cs
new file mode 100644
index 00000000..fdf1ab32
--- /dev/null
+++ b/src/WixToolset.Core/Bind/GenerateDatabaseCommand.cs
@@ -0,0 +1,335 @@
+// 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.Bind
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using System.Globalization;
+    using System.IO;
+    using System.Text;
+    using WixToolset.Data;
+    using WixToolset.Extensibility;
+    using WixToolset.Msi;
+    using WixToolset.Core.Native;
+
+    internal class GenerateDatabaseCommand : ICommand
+    {
+        public int Codepage { private get; set; }
+
+        public IEnumerable<IBinderExtension> Extensions { private get; set; }
+
+        public IEnumerable<IBinderFileManager> FileManagers { private get; set; }
+
+        /// <summary>
+        /// Whether to keep columns added in a transform.
+        /// </summary>
+        public bool KeepAddedColumns { private get; set; }
+
+        public Output Output { private get; set; }
+
+        public string OutputPath { private get; set; }
+
+        public TableDefinitionCollection TableDefinitions { private get; set; }
+
+        public string TempFilesLocation { private get; set; }
+
+        /// <summary>
+        /// Whether to use a subdirectory based on the <paramref name="databaseFile"/> file name for intermediate files.
+        /// </summary>
+        public bool SuppressAddingValidationRows { private get; set; }
+
+        public bool UseSubDirectory { private get; set; }
+
+        public void Execute()
+        {
+            // Add the _Validation rows.
+            if (!this.SuppressAddingValidationRows)
+            {
+                Table validationTable = this.Output.EnsureTable(this.TableDefinitions["_Validation"]);
+
+                foreach (Table table in this.Output.Tables)
+                {
+                    if (!table.Definition.Unreal)
+                    {
+                        // Add the validation rows for this table.
+                        table.Definition.AddValidationRows(validationTable);
+                    }
+                }
+            }
+
+            // Set the base directory.
+            string baseDirectory = this.TempFilesLocation;
+
+            if (this.UseSubDirectory)
+            {
+                string filename = Path.GetFileNameWithoutExtension(this.OutputPath);
+                baseDirectory = Path.Combine(baseDirectory, filename);
+
+                // make sure the directory exists
+                Directory.CreateDirectory(baseDirectory);
+            }
+
+            try
+            {
+                OpenDatabase type = OpenDatabase.CreateDirect;
+
+                // set special flag for patch files
+                if (OutputType.Patch == this.Output.Type)
+                {
+                    type |= OpenDatabase.OpenPatchFile;
+                }
+
+#if DEBUG
+                Console.WriteLine("Opening database at: {0}", this.OutputPath);
+#endif
+
+                using (Database db = new Database(this.OutputPath, type))
+                {
+                    // Localize the codepage if a value was specified directly.
+                    if (-1 != this.Codepage)
+                    {
+                        this.Output.Codepage = this.Codepage;
+                    }
+
+                    // if we're not using the default codepage, import a new one into our
+                    // database before we add any tables (or the tables would be added
+                    // with the wrong codepage).
+                    if (0 != this.Output.Codepage)
+                    {
+                        this.SetDatabaseCodepage(db, this.Output.Codepage);
+                    }
+
+                    foreach (Table table in this.Output.Tables)
+                    {
+                        Table importTable = table;
+                        bool hasBinaryColumn = false;
+
+                        // Skip all unreal tables other than _Streams.
+                        if (table.Definition.Unreal && "_Streams" != table.Name)
+                        {
+                            continue;
+                        }
+
+                        // Do not put the _Validation table in patches, it is not needed.
+                        if (OutputType.Patch == this.Output.Type && "_Validation" == table.Name)
+                        {
+                            continue;
+                        }
+
+                        // The only way to import binary data is to copy it to a local subdirectory first.
+                        // To avoid this extra copying and perf hit, import an empty table with the same
+                        // definition and later import the binary data from source using records.
+                        foreach (ColumnDefinition columnDefinition in table.Definition.Columns)
+                        {
+                            if (ColumnType.Object == columnDefinition.Type)
+                            {
+                                importTable = new Table(table.Section, table.Definition);
+                                hasBinaryColumn = true;
+                                break;
+                            }
+                        }
+
+                        // Create the table via IDT import.
+                        if ("_Streams" != importTable.Name)
+                        {
+                            try
+                            {
+                                db.ImportTable(this.Output.Codepage, importTable, baseDirectory, this.KeepAddedColumns);
+                            }
+                            catch (WixInvalidIdtException)
+                            {
+                                // If ValidateRows finds anything it doesn't like, it throws
+                                importTable.ValidateRows();
+
+                                // Otherwise we rethrow the InvalidIdt
+                                throw;
+                            }
+                        }
+
+                        // insert the rows via SQL query if this table contains object fields
+                        if (hasBinaryColumn)
+                        {
+                            StringBuilder query = new StringBuilder("SELECT ");
+
+                            // Build the query for the view.
+                            bool firstColumn = true;
+                            foreach (ColumnDefinition columnDefinition in table.Definition.Columns)
+                            {
+                                if (!firstColumn)
+                                {
+                                    query.Append(",");
+                                }
+
+                                query.AppendFormat(" `{0}`", columnDefinition.Name);
+                                firstColumn = false;
+                            }
+                            query.AppendFormat(" FROM `{0}`", table.Name);
+
+                            using (View tableView = db.OpenExecuteView(query.ToString()))
+                            {
+                                // Import each row containing a stream
+                                foreach (Row row in table.Rows)
+                                {
+                                    using (Record record = new Record(table.Definition.Columns.Count))
+                                    {
+                                        StringBuilder streamName = new StringBuilder();
+                                        bool needStream = false;
+
+                                        // the _Streams table doesn't prepend the table name (or a period)
+                                        if ("_Streams" != table.Name)
+                                        {
+                                            streamName.Append(table.Name);
+                                        }
+
+                                        for (int i = 0; i < table.Definition.Columns.Count; i++)
+                                        {
+                                            ColumnDefinition columnDefinition = table.Definition.Columns[i];
+
+                                            switch (columnDefinition.Type)
+                                            {
+                                                case ColumnType.Localized:
+                                                case ColumnType.Preserved:
+                                                case ColumnType.String:
+                                                    if (columnDefinition.PrimaryKey)
+                                                    {
+                                                        if (0 < streamName.Length)
+                                                        {
+                                                            streamName.Append(".");
+                                                        }
+                                                        streamName.Append((string)row[i]);
+                                                    }
+
+                                                    record.SetString(i + 1, (string)row[i]);
+                                                    break;
+                                                case ColumnType.Number:
+                                                    record.SetInteger(i + 1, Convert.ToInt32(row[i], CultureInfo.InvariantCulture));
+                                                    break;
+                                                case ColumnType.Object:
+                                                    if (null != row[i])
+                                                    {
+                                                        needStream = true;
+                                                        try
+                                                        {
+                                                            record.SetStream(i + 1, (string)row[i]);
+                                                        }
+                                                        catch (Win32Exception e)
+                                                        {
+                                                            if (0xA1 == e.NativeErrorCode) // ERROR_BAD_PATHNAME
+                                                            {
+                                                                throw new WixException(WixErrors.FileNotFound(row.SourceLineNumbers, (string)row[i]));
+                                                            }
+                                                            else
+                                                            {
+                                                                throw new WixException(WixErrors.Win32Exception(e.NativeErrorCode, e.Message));
+                                                            }
+                                                        }
+                                                    }
+                                                    break;
+                                            }
+                                        }
+
+                                        // stream names are created by concatenating the name of the table with the values
+                                        // of the primary key (delimited by periods)
+                                        // check for a stream name that is more than 62 characters long (the maximum allowed length)
+                                        if (needStream && MsiInterop.MsiMaxStreamNameLength < streamName.Length)
+                                        {
+                                            Messaging.Instance.OnMessage(WixErrors.StreamNameTooLong(row.SourceLineNumbers, table.Name, streamName.ToString(), streamName.Length));
+                                        }
+                                        else // add the row to the database
+                                        {
+                                            tableView.Modify(ModifyView.Assign, record);
+                                        }
+                                    }
+                                }
+                            }
+
+                            // Remove rows from the _Streams table for wixpdbs.
+                            if ("_Streams" == table.Name)
+                            {
+                                table.Rows.Clear();
+                            }
+                        }
+                    }
+
+                    // Insert substorages (usually transforms inside a patch or instance transforms in a package).
+                    if (0 < this.Output.SubStorages.Count)
+                    {
+                        using (View storagesView = new View(db, "SELECT `Name`, `Data` FROM `_Storages`"))
+                        {
+                            foreach (SubStorage subStorage in this.Output.SubStorages)
+                            {
+                                string transformFile = Path.Combine(this.TempFilesLocation, String.Concat(subStorage.Name, ".mst"));
+
+                                // Bind the transform.
+                                this.BindTransform(subStorage.Data, transformFile);
+
+                                if (Messaging.Instance.EncounteredError)
+                                {
+                                    continue;
+                                }
+
+                                // add the storage
+                                using (Record record = new Record(2))
+                                {
+                                    record.SetString(1, subStorage.Name);
+                                    record.SetStream(2, transformFile);
+                                    storagesView.Modify(ModifyView.Assign, record);
+                                }
+                            }
+                        }
+                    }
+
+                    // We're good, commit the changes to the new database.
+                    db.Commit();
+                }
+            }
+            catch (IOException)
+            {
+                // TODO: this error message doesn't seem specific enough
+                throw new WixFileNotFoundException(new SourceLineNumber(this.OutputPath), this.OutputPath);
+            }
+        }
+
+        private void BindTransform(Output transform, string outputPath)
+        {
+            BindTransformCommand command = new BindTransformCommand();
+            command.Extensions = this.Extensions;
+            command.FileManagers = this.FileManagers;
+            command.TempFilesLocation = this.TempFilesLocation;
+            command.Transform = transform;
+            command.OutputPath = outputPath;
+            command.TableDefinitions = this.TableDefinitions;
+            command.Execute();
+        }
+
+        /// <summary>
+        /// Sets the codepage of a database.
+        /// </summary>
+        /// <param name="db">Database to set codepage into.</param>
+        /// <param name="output">Output with the codepage for the database.</param>
+        private void SetDatabaseCodepage(Database db, int codepage)
+        {
+            // write out the _ForceCodepage IDT file
+            string idtPath = Path.Combine(this.TempFilesLocation, "_ForceCodepage.idt");
+            using (StreamWriter idtFile = new StreamWriter(idtPath, false, Encoding.ASCII))
+            {
+                idtFile.WriteLine(); // dummy column name record
+                idtFile.WriteLine(); // dummy column definition record
+                idtFile.Write(codepage);
+                idtFile.WriteLine("\t_ForceCodepage");
+            }
+
+            // try to import the table into the MSI
+            try
+            {
+                db.Import(idtPath);
+            }
+            catch (WixInvalidIdtException)
+            {
+                // the IDT should be valid, so an invalid code page was given
+                throw new WixException(WixErrors.IllegalCodepage(codepage));
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/ResolveDelayedFieldsCommand.cs b/src/WixToolset.Core/Bind/ResolveDelayedFieldsCommand.cs
new file mode 100644
index 00000000..4ffe9e82
--- /dev/null
+++ b/src/WixToolset.Core/Bind/ResolveDelayedFieldsCommand.cs
@@ -0,0 +1,121 @@
+// 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.Bind
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Linq;
+    using System.Text;
+    using WixToolset.Data;
+
+    /// <summary>
+    /// Resolves the fields which had variables that needed to be resolved after the file information
+    /// was loaded.
+    /// </summary>
+    internal class ResolveDelayedFieldsCommand : ICommand
+    {
+        public OutputType OutputType { private get; set;}
+
+        public IEnumerable<DelayedField> DelayedFields { private get; set;}
+
+        public IDictionary<string, string> VariableCache { private get; set; }
+
+        public string ModularizationGuid { private get; set; }
+
+        /// <param name="output">Internal representation of the msi database to operate upon.</param>
+        /// <param name="delayedFields">The fields which had resolution delayed.</param>
+        /// <param name="variableCache">The file information to use when resolving variables.</param>
+        /// <param name="modularizationGuid">The modularization guid (used in case of a merge module).</param>
+        public void Execute()
+        {
+            List<DelayedField> deferredFields = new List<DelayedField>();
+
+            foreach (DelayedField delayedField in this.DelayedFields)
+            {
+                try
+                {
+                    Row propertyRow = delayedField.Row;
+
+                    // process properties first in case they refer to other binder variables
+                    if ("Property" == propertyRow.Table.Name)
+                    {
+                        string value = WixVariableResolver.ResolveDelayedVariables(propertyRow.SourceLineNumbers, (string)delayedField.Field.Data, this.VariableCache);
+
+                        // update the variable cache with the new value
+                        string key = String.Concat("property.", BindDatabaseCommand.Demodularize(this.OutputType, this.ModularizationGuid, (string)propertyRow[0]));
+                        this.VariableCache[key] = value;
+
+                        // update the field data
+                        delayedField.Field.Data = value;
+                    }
+                    else
+                    {
+                        deferredFields.Add(delayedField);
+                    }
+                }
+                catch (WixException we)
+                {
+                    Messaging.Instance.OnMessage(we.Error);
+                    continue;
+                }
+            }
+
+            // add specialization for ProductVersion fields
+            string keyProductVersion = "property.ProductVersion";
+            if (this.VariableCache.ContainsKey(keyProductVersion))
+            {
+                string value = this.VariableCache[keyProductVersion];
+                Version productVersion = null;
+
+                try
+                {
+                    productVersion = new Version(value);
+
+                    // Don't add the variable if it already exists (developer defined a property with the same name).
+                    string fieldKey = String.Concat(keyProductVersion, ".Major");
+                    if (!this.VariableCache.ContainsKey(fieldKey))
+                    {
+                        this.VariableCache[fieldKey] = productVersion.Major.ToString(CultureInfo.InvariantCulture);
+                    }
+
+                    fieldKey = String.Concat(keyProductVersion, ".Minor");
+                    if (!this.VariableCache.ContainsKey(fieldKey))
+                    {
+                        this.VariableCache[fieldKey] = productVersion.Minor.ToString(CultureInfo.InvariantCulture);
+                    }
+
+                    fieldKey = String.Concat(keyProductVersion, ".Build");
+                    if (!this.VariableCache.ContainsKey(fieldKey))
+                    {
+                        this.VariableCache[fieldKey] = productVersion.Build.ToString(CultureInfo.InvariantCulture);
+                    }
+
+                    fieldKey = String.Concat(keyProductVersion, ".Revision");
+                    if (!this.VariableCache.ContainsKey(fieldKey))
+                    {
+                        this.VariableCache[fieldKey] = productVersion.Revision.ToString(CultureInfo.InvariantCulture);
+                    }
+                }
+                catch
+                {
+                    // Ignore the error introduced by new behavior.
+                }
+            }
+
+            // process the remaining fields in case they refer to property binder variables
+            foreach (DelayedField delayedField in deferredFields)
+            {
+                try
+                {
+                    delayedField.Field.Data = WixVariableResolver.ResolveDelayedVariables(delayedField.Row.SourceLineNumbers, (string)delayedField.Field.Data, this.VariableCache);
+                }
+                catch (WixException we)
+                {
+                    Messaging.Instance.OnMessage(we.Error);
+                    continue;
+                }
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/ResolveFieldsCommand.cs b/src/WixToolset.Core/Bind/ResolveFieldsCommand.cs
new file mode 100644
index 00000000..4caec9b4
--- /dev/null
+++ b/src/WixToolset.Core/Bind/ResolveFieldsCommand.cs
@@ -0,0 +1,215 @@
+// 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.Bind
+{
+    using System.Collections.Generic;
+    using WixToolset.Data;
+    using WixToolset.Extensibility;
+
+    /// <summary>
+    /// Resolve source fields in the tables included in the output
+    /// </summary>
+    internal class ResolveFieldsCommand : ICommand
+    {
+        public TableIndexedCollection Tables { private get; set; }
+
+        public ExtractEmbeddedFiles FilesWithEmbeddedFiles { private get; set; }
+
+        public BinderFileManagerCore FileManagerCore { private get; set; }
+
+        public IEnumerable<IBinderFileManager> FileManagers { private get; set; }
+
+        public bool SupportDelayedResolution { private get; set; }
+
+        public string TempFilesLocation { private get; set; }
+
+        public WixVariableResolver WixVariableResolver { private get; set; }
+
+        public IEnumerable<DelayedField> DelayedFields { get; private set; }
+
+        public void Execute()
+        {
+            List<DelayedField> delayedFields = this.SupportDelayedResolution ? new List<DelayedField>() : null;
+
+            foreach (Table table in this.Tables)
+            {
+                foreach (Row row in table.Rows)
+                {
+                    foreach (Field field in row.Fields)
+                    {
+                        bool isDefault = true;
+                        bool delayedResolve = false;
+
+                        // Check to make sure we're in a scenario where we can handle variable resolution.
+                        if (null != delayedFields)
+                        {
+                            // resolve localization and wix variables
+                            if (field.Data is string)
+                            {
+                                field.Data = this.WixVariableResolver.ResolveVariables(row.SourceLineNumbers, field.AsString(), false, ref isDefault, ref delayedResolve);
+                                if (delayedResolve)
+                                {
+                                    delayedFields.Add(new DelayedField(row, field));
+                                }
+                            }
+                        }
+
+                        // Move to next row if we've hit an error resolving variables.
+                        if (Messaging.Instance.EncounteredError) // TODO: make this error handling more specific to just the failure to resolve variables in this field.
+                        {
+                            continue;
+                        }
+
+                        // Resolve file paths
+                        if (ColumnType.Object == field.Column.Type)
+                        {
+                            ObjectField objectField = (ObjectField)field;
+
+                            // Skip file resolution if the file is to be deleted.
+                            if (RowOperation.Delete == row.Operation)
+                            {
+                                continue;
+                            }
+
+                            // File is embedded and path to it was not modified above.
+                            if (objectField.EmbeddedFileIndex.HasValue && isDefault)
+                            {
+                                string extractPath = this.FilesWithEmbeddedFiles.AddEmbeddedFileIndex(objectField.BaseUri, objectField.EmbeddedFileIndex.Value, this.TempFilesLocation);
+
+                                // Set the path to the embedded file once where it will be extracted.
+                                objectField.Data = extractPath;
+                            }
+                            else if (null != objectField.Data) // non-compressed file (or localized value)
+                            {
+                                try
+                                {
+                                    if (OutputType.Patch != this.FileManagerCore.Output.Type) // Normal binding for non-Patch scenario such as link (light.exe)
+                                    {
+                                        // keep a copy of the un-resolved data for future replay. This will be saved into wixpdb file
+                                        if (null == objectField.UnresolvedData)
+                                        {
+                                            objectField.UnresolvedData = (string)objectField.Data;
+                                        }
+
+                                        // resolve the path to the file
+                                        objectField.Data = this.ResolveFile((string)objectField.Data, table.Name, row.SourceLineNumbers, BindStage.Normal);
+                                    }
+                                    else if (!(this.FileManagerCore.RebaseTarget || this.FileManagerCore.RebaseUpdated)) // Normal binding for Patch Scenario (normal patch, no re-basing logic)
+                                    {
+                                        // resolve the path to the file
+                                        objectField.Data = this.ResolveFile((string)objectField.Data, table.Name, row.SourceLineNumbers, BindStage.Normal);
+                                    }
+                                    else // Re-base binding path scenario caused by pyro.exe -bt -bu
+                                    {
+                                        // by default, use the resolved Data for file lookup
+                                        string filePathToResolve = (string)objectField.Data;
+
+                                        // if -bu is used in pyro command, this condition holds true and the tool
+                                        // will use pre-resolved source for new wixpdb file
+                                        if (this.FileManagerCore.RebaseUpdated)
+                                        {
+                                            // try to use the unResolved Source if it exists.
+                                            // New version of wixpdb file keeps a copy of pre-resolved Source. i.e. !(bindpath.test)\foo.dll
+                                            // Old version of winpdb file does not contain this attribute and the value is null.
+                                            if (null != objectField.UnresolvedData)
+                                            {
+                                                filePathToResolve = objectField.UnresolvedData;
+                                            }
+                                        }
+
+                                        objectField.Data = this.ResolveFile(filePathToResolve, table.Name, row.SourceLineNumbers, BindStage.Updated);
+                                    }
+                                }
+                                catch (WixFileNotFoundException)
+                                {
+                                    // display the error with source line information
+                                    Messaging.Instance.OnMessage(WixErrors.FileNotFound(row.SourceLineNumbers, (string)objectField.Data));
+                                }
+                            }
+
+                            isDefault = true;
+                            if (null != objectField.PreviousData)
+                            {
+                                objectField.PreviousData = this.WixVariableResolver.ResolveVariables(row.SourceLineNumbers, objectField.PreviousData, false, ref isDefault);
+                                if (!Messaging.Instance.EncounteredError) // TODO: make this error handling more specific to just the failure to resolve variables in this field.
+                                {
+                                    // file is compressed in a cabinet (and not modified above)
+                                    if (objectField.PreviousEmbeddedFileIndex.HasValue && isDefault)
+                                    {
+                                        // when loading transforms from disk, PreviousBaseUri may not have been set
+                                        if (null == objectField.PreviousBaseUri)
+                                        {
+                                            objectField.PreviousBaseUri = objectField.BaseUri;
+                                        }
+
+                                        string extractPath = this.FilesWithEmbeddedFiles.AddEmbeddedFileIndex(objectField.PreviousBaseUri, objectField.PreviousEmbeddedFileIndex.Value, this.TempFilesLocation);
+
+                                        // set the path to the file once its extracted from the cabinet
+                                        objectField.PreviousData = extractPath;
+                                    }
+                                    else if (null != objectField.PreviousData) // non-compressed file (or localized value)
+                                    {
+                                        try
+                                        {
+                                            if (!this.FileManagerCore.RebaseTarget && !this.FileManagerCore.RebaseUpdated)
+                                            {
+                                                // resolve the path to the file
+                                                objectField.PreviousData = this.ResolveFile((string)objectField.PreviousData, table.Name, row.SourceLineNumbers, BindStage.Normal);
+                                            }
+                                            else
+                                            {
+                                                if (this.FileManagerCore.RebaseTarget)
+                                                {
+                                                    // if -bt is used, it come here
+                                                    // Try to use the original unresolved source from either target build or update build
+                                                    // If both target and updated are of old wixpdb, it behaves the same as today, no re-base logic here
+                                                    // If target is old version and updated is new version, it uses unresolved path from updated build
+                                                    // If both target and updated are of new versions, it uses unresolved path from target build
+                                                    if (null != objectField.UnresolvedPreviousData || null != objectField.UnresolvedData)
+                                                    {
+                                                        objectField.PreviousData = objectField.UnresolvedPreviousData ?? objectField.UnresolvedData;
+                                                    }
+                                                }
+
+                                                // resolve the path to the file
+                                                objectField.PreviousData = this.ResolveFile((string)objectField.PreviousData, table.Name, row.SourceLineNumbers, BindStage.Target);
+
+                                            }
+                                        }
+                                        catch (WixFileNotFoundException)
+                                        {
+                                            // display the error with source line information
+                                            Messaging.Instance.OnMessage(WixErrors.FileNotFound(row.SourceLineNumbers, (string)objectField.PreviousData));
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            this.DelayedFields = delayedFields;
+        }
+
+        private string ResolveFile(string source, string type, SourceLineNumber sourceLineNumbers, BindStage bindStage = BindStage.Normal)
+        {
+            string path = null;
+            foreach (IBinderFileManager fileManager in this.FileManagers)
+            {
+                path = fileManager.ResolveFile(source, type, sourceLineNumbers, bindStage);
+                if (null != path)
+                {
+                    break;
+                }
+            }
+
+            if (null == path)
+            {
+                throw new WixFileNotFoundException(sourceLineNumbers, source, type);
+            }
+
+            return path;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/ResolvedDirectory.cs b/src/WixToolset.Core/Bind/ResolvedDirectory.cs
new file mode 100644
index 00000000..6985f95d
--- /dev/null
+++ b/src/WixToolset.Core/Bind/ResolvedDirectory.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.Bind
+{
+    /// <summary>
+    /// Structure used for resolved directory information.
+    /// </summary>
+    internal struct ResolvedDirectory
+    {
+        /// <summary>The directory parent.</summary>
+        public string DirectoryParent;
+
+        /// <summary>The name of this directory.</summary>
+        public string Name;
+
+        /// <summary>The path of this directory.</summary>
+        public string Path;
+
+        /// <summary>
+        /// Constructor for ResolvedDirectory.
+        /// </summary>
+        /// <param name="directoryParent">Parent directory.</param>
+        /// <param name="name">The directory name.</param>
+        public ResolvedDirectory(string directoryParent, string name)
+        {
+            this.DirectoryParent = directoryParent;
+            this.Name = name;
+            this.Path = null;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Bind/TransferFilesCommand.cs b/src/WixToolset.Core/Bind/TransferFilesCommand.cs
new file mode 100644
index 00000000..719b8b20
--- /dev/null
+++ b/src/WixToolset.Core/Bind/TransferFilesCommand.cs
@@ -0,0 +1,214 @@
+// 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.Bind
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Security.AccessControl;
+    using WixToolset.Data;
+    using WixToolset.Extensibility;
+
+    internal class TransferFilesCommand : ICommand
+    {
+        public IEnumerable<IBinderFileManager> FileManagers { private get; set; }
+
+        public IEnumerable<FileTransfer> FileTransfers { private get; set; }
+
+        public bool SuppressAclReset { private get; set; }
+
+        public void Execute()
+        {
+            List<string> destinationFiles = new List<string>();
+
+            foreach (FileTransfer fileTransfer in this.FileTransfers)
+            {
+                string fileSource = this.ResolveFile(fileTransfer.Source, fileTransfer.Type, fileTransfer.SourceLineNumbers, BindStage.Normal);
+
+                // If the source and destination are identical, then there's nothing to do here
+                if (0 == String.Compare(fileSource, fileTransfer.Destination, StringComparison.OrdinalIgnoreCase))
+                {
+                    fileTransfer.Redundant = true;
+                    continue;
+                }
+
+                bool retry = false;
+                do
+                {
+                    try
+                    {
+                        if (fileTransfer.Move)
+                        {
+                            Messaging.Instance.OnMessage(WixVerboses.MoveFile(fileSource, fileTransfer.Destination));
+                            this.TransferFile(true, fileSource, fileTransfer.Destination);
+                        }
+                        else
+                        {
+                            Messaging.Instance.OnMessage(WixVerboses.CopyFile(fileSource, fileTransfer.Destination));
+                            this.TransferFile(false, fileSource, fileTransfer.Destination);
+                        }
+
+                        retry = false;
+                        destinationFiles.Add(fileTransfer.Destination);
+                    }
+                    catch (FileNotFoundException e)
+                    {
+                        throw new WixFileNotFoundException(e.FileName);
+                    }
+                    catch (DirectoryNotFoundException)
+                    {
+                        // if we already retried, give up
+                        if (retry)
+                        {
+                            throw;
+                        }
+
+                        string directory = Path.GetDirectoryName(fileTransfer.Destination);
+                        Messaging.Instance.OnMessage(WixVerboses.CreateDirectory(directory));
+                        Directory.CreateDirectory(directory);
+                        retry = true;
+                    }
+                    catch (UnauthorizedAccessException)
+                    {
+                        // if we already retried, give up
+                        if (retry)
+                        {
+                            throw;
+                        }
+
+                        if (File.Exists(fileTransfer.Destination))
+                        {
+                            Messaging.Instance.OnMessage(WixVerboses.RemoveDestinationFile(fileTransfer.Destination));
+
+                            // try to ensure the file is not read-only
+                            FileAttributes attributes = File.GetAttributes(fileTransfer.Destination);
+                            try
+                            {
+                                File.SetAttributes(fileTransfer.Destination, attributes & ~FileAttributes.ReadOnly);
+                            }
+                            catch (ArgumentException) // thrown for unauthorized access errors
+                            {
+                                throw new WixException(WixErrors.UnauthorizedAccess(fileTransfer.Destination));
+                            }
+
+                            // try to delete the file
+                            try
+                            {
+                                File.Delete(fileTransfer.Destination);
+                            }
+                            catch (IOException)
+                            {
+                                throw new WixException(WixErrors.FileInUse(null, fileTransfer.Destination));
+                            }
+
+                            retry = true;
+                        }
+                        else // no idea what just happened, bail
+                        {
+                            throw;
+                        }
+                    }
+                    catch (IOException)
+                    {
+                        // if we already retried, give up
+                        if (retry)
+                        {
+                            throw;
+                        }
+
+                        if (File.Exists(fileTransfer.Destination))
+                        {
+                            Messaging.Instance.OnMessage(WixVerboses.RemoveDestinationFile(fileTransfer.Destination));
+
+                            // ensure the file is not read-only, then delete it
+                            FileAttributes attributes = File.GetAttributes(fileTransfer.Destination);
+                            File.SetAttributes(fileTransfer.Destination, attributes & ~FileAttributes.ReadOnly);
+                            try
+                            {
+                                File.Delete(fileTransfer.Destination);
+                            }
+                            catch (IOException)
+                            {
+                                throw new WixException(WixErrors.FileInUse(null, fileTransfer.Destination));
+                            }
+
+                            retry = true;
+                        }
+                        else // no idea what just happened, bail
+                        {
+                            throw;
+                        }
+                    }
+                } while (retry);
+            }
+
+            // Finally, if there were any files remove the ACL that may have been added to
+            // during the file transfer process.
+            if (0 < destinationFiles.Count && !this.SuppressAclReset)
+            {
+                var aclReset = new FileSecurity();
+                aclReset.SetAccessRuleProtection(false, false);
+
+                try
+                {
+                    //WixToolset.Core.Native.NativeMethods.ResetAcls(destinationFiles.ToArray(), (uint)destinationFiles.Count);
+
+                    foreach (var file in destinationFiles)
+                    {
+                        new FileInfo(file).SetAccessControl(aclReset);
+                    }
+                }
+                catch
+                {
+                    Messaging.Instance.OnMessage(WixWarnings.UnableToResetAcls());
+                }
+            }
+        }
+
+        private string ResolveFile(string source, string type, SourceLineNumber sourceLineNumbers, BindStage bindStage)
+        {
+            string path = null;
+            foreach (IBinderFileManager fileManager in this.FileManagers)
+            {
+                path = fileManager.ResolveFile(source, type, sourceLineNumbers, bindStage);
+                if (null != path)
+                {
+                    break;
+                }
+            }
+
+            if (null == path)
+            {
+                throw new WixFileNotFoundException(sourceLineNumbers, source, type);
+            }
+
+            return path;
+        }
+
+        private void TransferFile(bool move, string source, string destination)
+        {
+            bool complete = false;
+            foreach (IBinderFileManager fileManager in this.FileManagers)
+            {
+                if (move)
+                {
+                    complete = fileManager.MoveFile(source, destination, true);
+                }
+                else
+                {
+                    complete = fileManager.CopyFile(source, destination, true);
+                }
+
+                if (complete)
+                {
+                    break;
+                }
+            }
+
+            if (!complete)
+            {
+                throw new InvalidOperationException(); // TODO: something needs to be said here that none of the binder file managers returned a result.
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Binder.cs b/src/WixToolset.Core/Binder.cs
new file mode 100644
index 00000000..18ad2d62
--- /dev/null
+++ b/src/WixToolset.Core/Binder.cs
@@ -0,0 +1,686 @@
+// 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
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Globalization;
+    using System.IO;
+    using System.Linq;
+    using System.Reflection;
+    using WixToolset.Bind;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+    using WixToolset.Extensibility;
+    using WixToolset.Msi;
+
+    // TODO: (4.0) Refactor so that these don't need to be copied.
+    // Copied verbatim from ext\UtilExtension\wixext\UtilCompiler.cs
+    [Flags]
+    internal enum WixFileSearchAttributes
+    {
+        Default = 0x001,
+        MinVersionInclusive = 0x002,
+        MaxVersionInclusive = 0x004,
+        MinSizeInclusive = 0x008,
+        MaxSizeInclusive = 0x010,
+        MinDateInclusive = 0x020,
+        MaxDateInclusive = 0x040,
+        WantVersion = 0x080,
+        WantExists = 0x100,
+        IsDirectory = 0x200,
+    }
+
+    [Flags]
+    internal enum WixRegistrySearchAttributes
+    {
+        Raw = 0x01,
+        Compatible = 0x02,
+        ExpandEnvironmentVariables = 0x04,
+        WantValue = 0x08,
+        WantExists = 0x10,
+        Win64 = 0x20,
+    }
+
+    internal enum WixComponentSearchAttributes
+    {
+        KeyPath = 0x1,
+        State = 0x2,
+        WantDirectory = 0x4,
+    }
+
+    [Flags]
+    internal enum WixProductSearchAttributes
+    {
+        Version = 0x1,
+        Language = 0x2,
+        State = 0x4,
+        Assignment = 0x8,
+        UpgradeCode = 0x10,
+    }
+
+    /// <summary>
+    /// Binder of the WiX toolset.
+    /// </summary>
+    public sealed class Binder
+    {
+        private BinderCore core;
+        private BinderFileManagerCore fileManagerCore;
+        private List<IBinderExtension> extensions;
+        private List<IBinderFileManager> fileManagers;
+        private List<InspectorExtension> inspectorExtensions;
+
+        public Binder()
+        {
+            this.DefaultCompressionLevel = CompressionLevel.High;
+
+            this.BindPaths = new List<BindPath>();
+            this.TargetBindPaths = new List<BindPath>();
+            this.UpdatedBindPaths = new List<BindPath>();
+
+            this.extensions = new List<IBinderExtension>();
+            this.fileManagers = new List<IBinderFileManager>();
+            this.inspectorExtensions = new List<InspectorExtension>();
+
+            this.Ices = new List<string>();
+            this.SuppressIces = new List<string>();
+        }
+
+        public string ContentsFile { private get; set; }
+
+        public string OutputsFile { private get; set; }
+
+        public string BuiltOutputsFile { private get; set; }
+
+        public string WixprojectFile { private get; set; }
+
+        /// <summary>
+        /// Gets the list of bindpaths.
+        /// </summary>
+        public List<BindPath> BindPaths { get; private set; }
+
+        /// <summary>
+        /// Gets the list of target bindpaths.
+        /// </summary>
+        public List<BindPath> TargetBindPaths { get; private set; }
+
+        /// <summary>
+        /// Gets the list of updated bindpaths.
+        /// </summary>
+        public List<BindPath> UpdatedBindPaths { get; private set; }
+
+        /// <summary>
+        /// Gets or sets the option to enable building binary delta patches.
+        /// </summary>
+        /// <value>The option to enable building binary delta patches.</value>
+        public bool DeltaBinaryPatch { get; set; }
+
+        /// <summary>
+        /// Gets or sets the cabinet cache location.
+        /// </summary>
+        public string CabCachePath { get; set; }
+
+        /// <summary>
+        /// Gets or sets the number of threads to use for cabinet creation.
+        /// </summary>
+        /// <value>The number of threads to use for cabinet creation.</value>
+        public int CabbingThreadCount { get; set; }
+
+        /// <summary>
+        /// Gets or sets the default compression level to use for cabinets
+        /// that don't have their compression level explicitly set.
+        /// </summary>
+        public CompressionLevel DefaultCompressionLevel { get; set; }
+
+        /// <summary>
+        /// Gets and sets the location to save the WixPdb.
+        /// </summary>
+        /// <value>The location in which to save the WixPdb. Null if the the WixPdb should not be output.</value>
+        public string PdbFile { get; set; }
+
+        public List<string> Ices { get; private set; }
+
+        public List<string> SuppressIces { get; private set; }
+
+        /// <summary>
+        /// Gets and sets the option to suppress resetting ACLs by the binder.
+        /// </summary>
+        /// <value>The option to suppress resetting ACLs by the binder.</value>
+        public bool SuppressAclReset { get; set; }
+
+        /// <summary>
+        /// Gets and sets the option to suppress creating an image for MSI/MSM.
+        /// </summary>
+        /// <value>The option to suppress creating an image for MSI/MSM.</value>
+        public bool SuppressLayout { get; set; }
+
+        /// <summary>
+        /// Gets and sets the option to suppress MSI/MSM validation.
+        /// </summary>
+        /// <value>The option to suppress MSI/MSM validation.</value>
+        /// <remarks>This must be set before calling Bind.</remarks>
+        public bool SuppressValidation { get; set; }
+
+        /// <summary>
+        /// Gets and sets the option to suppress adding _Validation table rows.
+        /// </summary>
+        public bool SuppressAddingValidationRows { get; set; }
+
+        /// <summary>
+        /// Gets or sets the localizer.
+        /// </summary>
+        /// <value>The localizer.</value>
+        public Localizer Localizer { get; set; }
+
+        /// <summary>
+        /// Gets or sets the temporary path for the Binder.  If left null, the binder
+        /// will use %TEMP% environment variable.
+        /// </summary>
+        /// <value>Path to temp files.</value>
+        public string TempFilesLocation { get; set; }
+
+        /// <summary>
+        /// Gets or sets the Wix variable resolver.
+        /// </summary>
+        /// <value>The Wix variable resolver.</value>
+        public WixVariableResolver WixVariableResolver { get; set; }
+
+        /// <summary>
+        /// Add a binder extension.
+        /// </summary>
+        /// <param name="extension">New extension.</param>
+        public void AddExtension(IBinderExtension extension)
+        {
+            this.extensions.Add(extension);
+        }
+
+        /// <summary>
+        /// Add a file manager extension.
+        /// </summary>
+        /// <param name="extension">New file manager.</param>
+        public void AddExtension(IBinderFileManager extension)
+        {
+            this.fileManagers.Add(extension);
+        }
+
+        /// <summary>
+        /// Binds an output.
+        /// </summary>
+        /// <param name="output">The output to bind.</param>
+        /// <param name="file">The Windows Installer file to create.</param>
+        /// <remarks>The Binder.DeleteTempFiles method should be called after calling this method.</remarks>
+        /// <returns>true if binding completed successfully; false otherwise</returns>
+        public bool Bind(Output output, string file)
+        {
+            // Ensure the cabinet cache path exists if we are going to use it.
+            if (!String.IsNullOrEmpty(this.CabCachePath))
+            {
+                Directory.CreateDirectory(this.CabCachePath);
+            }
+
+            this.fileManagerCore = new BinderFileManagerCore();
+            this.fileManagerCore.CabCachePath = this.CabCachePath;
+            this.fileManagerCore.Output = output;
+            this.fileManagerCore.TempFilesLocation = this.TempFilesLocation;
+            this.fileManagerCore.AddBindPaths(this.BindPaths, BindStage.Normal);
+            this.fileManagerCore.AddBindPaths(this.TargetBindPaths, BindStage.Target);
+            this.fileManagerCore.AddBindPaths(this.UpdatedBindPaths, BindStage.Updated);
+            foreach (IBinderFileManager fileManager in this.fileManagers)
+            {
+                fileManager.Core = this.fileManagerCore;
+            }
+
+            this.core = new BinderCore();
+            this.core.FileManagerCore = this.fileManagerCore;
+
+            this.WriteBuildInfoTable(output, file);
+
+            // Initialize extensions.
+            foreach (IBinderExtension extension in this.extensions)
+            {
+                extension.Core = this.core;
+
+                extension.Initialize(output);
+            }
+
+            // Gather all the wix variables.
+            Table wixVariableTable = output.Tables["WixVariable"];
+            if (null != wixVariableTable)
+            {
+                foreach (WixVariableRow wixVariableRow in wixVariableTable.Rows)
+                {
+                    this.WixVariableResolver.AddVariable(wixVariableRow);
+                }
+            }
+
+            IEnumerable<FileTransfer> fileTransfers = null;
+            IEnumerable<string> contentPaths = null;
+
+            switch (output.Type)
+            {
+                case OutputType.Bundle:
+                    this.BindBundle(output, file, out fileTransfers, out contentPaths);
+                    break;
+
+                case OutputType.Transform:
+                    this.BindTransform(output, file);
+                    break;
+
+                default:
+                    this.BindDatabase(output, file, out fileTransfers, out contentPaths);
+                    break;
+            }
+
+
+            // Layout media
+            try
+            {
+                this.LayoutMedia(fileTransfers);
+            }
+            finally
+            {
+                if (!String.IsNullOrEmpty(this.ContentsFile) && contentPaths != null)
+                {
+                    this.CreateContentsFile(this.ContentsFile, contentPaths);
+                }
+
+                if (!String.IsNullOrEmpty(this.OutputsFile) && fileTransfers != null)
+                {
+                    this.CreateOutputsFile(this.OutputsFile, fileTransfers, this.PdbFile);
+                }
+
+                if (!String.IsNullOrEmpty(this.BuiltOutputsFile) && fileTransfers != null)
+                {
+                    this.CreateBuiltOutputsFile(this.BuiltOutputsFile, fileTransfers, this.PdbFile);
+                }
+            }
+
+            this.core = null;
+
+            return Messaging.Instance.EncounteredError;
+        }
+
+        /// <summary>
+        /// Does any housekeeping after Bind.
+        /// </summary>
+        /// <param name="tidy">Whether or not any actual tidying should be done.</param>
+        public void Cleanup(bool tidy)
+        {
+            if (tidy)
+            {
+                if (!this.DeleteTempFiles())
+                {
+                    this.core.OnMessage(WixWarnings.FailedToDeleteTempDir(this.TempFilesLocation));
+                }
+            }
+            else
+            {
+                this.core.OnMessage(WixVerboses.BinderTempDirLocatedAt(this.TempFilesLocation));
+            }
+        }
+
+        /// <summary>
+        /// Cleans up the temp files used by the Binder.
+        /// </summary>
+        /// <returns>True if all files were deleted, false otherwise.</returns>
+        private bool DeleteTempFiles()
+        {
+            bool deleted = Common.DeleteTempFiles(this.TempFilesLocation, this.core);
+            return deleted;
+        }
+
+        /// <summary>
+        /// Populates the WixBuildInfo table in an output.
+        /// </summary>
+        /// <param name="output">The output.</param>
+        /// <param name="databaseFile">The output file if OutputFile not set.</param>
+        private void WriteBuildInfoTable(Output output, string outputFile)
+        {
+            Table buildInfoTable = output.EnsureTable(this.core.TableDefinitions["WixBuildInfo"]);
+            Row buildInfoRow = buildInfoTable.CreateRow(null);
+
+            Assembly executingAssembly = Assembly.GetExecutingAssembly();
+            FileVersionInfo fileVersion = FileVersionInfo.GetVersionInfo(executingAssembly.Location);
+            buildInfoRow[0] = fileVersion.FileVersion;
+            buildInfoRow[1] = outputFile;
+
+            if (!String.IsNullOrEmpty(this.WixprojectFile))
+            {
+                buildInfoRow[2] = this.WixprojectFile;
+            }
+
+            if (!String.IsNullOrEmpty(this.PdbFile))
+            {
+                buildInfoRow[3] = this.PdbFile;
+            }
+        }
+
+        /// <summary>
+        /// Binds a bundle.
+        /// </summary>
+        /// <param name="bundle">The bundle to bind.</param>
+        /// <param name="bundleFile">The bundle to create.</param>
+        private void BindBundle(Output bundle, string bundleFile, out IEnumerable<FileTransfer> fileTransfers, out IEnumerable<string> contentPaths)
+        {
+            BindBundleCommand command = new BindBundleCommand();
+            command.DefaultCompressionLevel = this.DefaultCompressionLevel;
+            command.Extensions = this.extensions;
+            command.FileManagerCore = this.fileManagerCore;
+            command.FileManagers = this.fileManagers;
+            command.Output = bundle;
+            command.OutputPath = bundleFile;
+            command.PdbFile = this.PdbFile;
+            command.TableDefinitions = this.core.TableDefinitions;
+            command.TempFilesLocation = this.TempFilesLocation;
+            command.WixVariableResolver = this.WixVariableResolver;
+            command.Execute();
+
+            fileTransfers = command.FileTransfers;
+            contentPaths = command.ContentFilePaths;
+        }
+
+        /// <summary>
+        /// Binds a databse.
+        /// </summary>
+        /// <param name="output">The output to bind.</param>
+        /// <param name="databaseFile">The database file to create.</param>
+        private void BindDatabase(Output output, string databaseFile, out IEnumerable<FileTransfer> fileTransfers, out IEnumerable<string> contentPaths)
+        {
+            Validator validator = null;
+
+            // tell the binder about the validator if validation isn't suppressed
+            if (!this.SuppressValidation && (OutputType.Module == output.Type || OutputType.Product == output.Type))
+            {
+                validator = new Validator();
+                validator.TempFilesLocation = Path.Combine(this.TempFilesLocation, "validate");
+
+                // set the default cube file
+                string lightDirectory = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
+                string cubePath = (OutputType.Module == output.Type) ? Path.Combine(lightDirectory, "mergemod.cub") : Path.Combine(lightDirectory, "darice.cub");
+                validator.AddCubeFile(cubePath);
+
+                // by default, disable ICEs that have equivalent-or-better checks in WiX
+                this.SuppressIces.Add("ICE08");
+                this.SuppressIces.Add("ICE33");
+                this.SuppressIces.Add("ICE47");
+                this.SuppressIces.Add("ICE66");
+
+                // set the ICEs
+                validator.ICEs = this.Ices.ToArray();
+
+                // set the suppressed ICEs
+                validator.SuppressedICEs = this.SuppressIces.ToArray();
+            }
+
+            BindDatabaseCommand command = new BindDatabaseCommand();
+            command.CabbingThreadCount = this.CabbingThreadCount;
+            command.Codepage = this.Localizer == null ? -1 : this.Localizer.Codepage;
+            command.DefaultCompressionLevel = this.DefaultCompressionLevel;
+            command.Extensions = this.extensions;
+            command.FileManagerCore = this.fileManagerCore;
+            command.FileManagers = this.fileManagers;
+            command.InspectorExtensions = this.inspectorExtensions;
+            command.Localizer = this.Localizer;
+            command.PdbFile = this.PdbFile;
+            command.Output = output;
+            command.OutputPath = databaseFile;
+            command.SuppressAddingValidationRows = this.SuppressAddingValidationRows;
+            command.SuppressLayout = this.SuppressLayout;
+            command.TableDefinitions = this.core.TableDefinitions;
+            command.TempFilesLocation = this.TempFilesLocation;
+            command.Validator = validator;
+            command.WixVariableResolver = this.WixVariableResolver;
+            command.Execute();
+
+            fileTransfers = command.FileTransfers;
+            contentPaths = command.ContentFilePaths;
+        }
+
+        /// <summary>
+        /// Binds a transform.
+        /// </summary>
+        /// <param name="transform">The transform to bind.</param>
+        /// <param name="outputPath">The transform to create.</param>
+        private void BindTransform(Output transform, string outputPath)
+        {
+            BindTransformCommand command = new BindTransformCommand();
+            command.Extensions = this.extensions;
+            command.FileManagers = this.fileManagers;
+            command.TableDefinitions = this.core.TableDefinitions;
+            command.TempFilesLocation = this.TempFilesLocation;
+            command.Transform = transform;
+            command.OutputPath = outputPath;
+            command.Execute();
+        }
+
+        /// <summary>
+        /// Final step in binding that transfers (moves/copies) all files generated into the appropriate
+        /// location in the source image
+        /// </summary>
+        /// <param name="fileTransfers">List of files to transfer.</param>
+        private void LayoutMedia(IEnumerable<FileTransfer> transfers)
+        {
+            if (null != transfers && transfers.Any())
+            {
+                this.core.OnMessage(WixVerboses.LayingOutMedia());
+
+                TransferFilesCommand command = new TransferFilesCommand();
+                command.FileManagers = this.fileManagers;
+                command.FileTransfers = transfers;
+                command.SuppressAclReset = this.SuppressAclReset;
+                command.Execute();
+            }
+        }
+
+        /// <summary>
+        /// Get the source path of a directory.
+        /// </summary>
+        /// <param name="directories">All cached directories.</param>
+        /// <param name="componentIdGenSeeds">Hash table of Component GUID generation seeds indexed by directory id.</param>
+        /// <param name="directory">Directory identifier.</param>
+        /// <param name="canonicalize">Canonicalize the path for standard directories.</param>
+        /// <returns>Source path of a directory.</returns>
+        internal static string GetDirectoryPath(Hashtable directories, Hashtable componentIdGenSeeds, string directory, bool canonicalize)
+        {
+            if (!directories.Contains(directory))
+            {
+                throw new WixException(WixErrors.ExpectedDirectory(directory));
+            }
+
+            ResolvedDirectory resolvedDirectory = (ResolvedDirectory)directories[directory];
+
+            if (null == resolvedDirectory.Path)
+            {
+                if (null != componentIdGenSeeds && componentIdGenSeeds.Contains(directory))
+                {
+                    resolvedDirectory.Path = (string)componentIdGenSeeds[directory];
+                }
+                else if (canonicalize && WindowsInstallerStandard.IsStandardDirectory(directory))
+                {
+                    // when canonicalization is on, standard directories are treated equally
+                    resolvedDirectory.Path = directory;
+                }
+                else
+                {
+                    string name = resolvedDirectory.Name;
+
+                    if (canonicalize && null != name)
+                    {
+                        name = name.ToLower(CultureInfo.InvariantCulture);
+                    }
+
+                    if (String.IsNullOrEmpty(resolvedDirectory.DirectoryParent))
+                    {
+                        resolvedDirectory.Path = name;
+                    }
+                    else
+                    {
+                        string parentPath = GetDirectoryPath(directories, componentIdGenSeeds, resolvedDirectory.DirectoryParent, canonicalize);
+
+                        if (null != resolvedDirectory.Name)
+                        {
+                            resolvedDirectory.Path = Path.Combine(parentPath, name);
+                        }
+                        else
+                        {
+                            resolvedDirectory.Path = parentPath;
+                        }
+                    }
+                }
+            }
+
+            return resolvedDirectory.Path;
+        }
+
+        /// <summary>
+        /// Gets the source path of a file.
+        /// </summary>
+        /// <param name="directories">All cached directories in <see cref="ResolvedDirectory"/>.</param>
+        /// <param name="directoryId">Parent directory identifier.</param>
+        /// <param name="fileName">File name (in long|source format).</param>
+        /// <param name="compressed">Specifies the package is compressed.</param>
+        /// <param name="useLongName">Specifies the package uses long file names.</param>
+        /// <returns>Source path of file relative to package directory.</returns>
+        internal static string GetFileSourcePath(Hashtable directories, string directoryId, string fileName, bool compressed, bool useLongName)
+        {
+            string fileSourcePath = Installer.GetName(fileName, true, useLongName);
+
+            if (compressed)
+            {
+                // Use just the file name of the file since all uncompressed files must appear
+                // in the root of the image in a compressed package.
+            }
+            else
+            {
+                // Get the relative path of where we want the file to be layed out as specified
+                // in the Directory table.
+                string directoryPath = Binder.GetDirectoryPath(directories, null, directoryId, false);
+                fileSourcePath = Path.Combine(directoryPath, fileSourcePath);
+            }
+
+            // Strip off "SourceDir" if it's still on there.
+            if (fileSourcePath.StartsWith("SourceDir\\", StringComparison.Ordinal))
+            {
+                fileSourcePath = fileSourcePath.Substring(10);
+            }
+
+            return fileSourcePath;
+        }
+
+        /// <summary>
+        /// Writes the paths to the content files included in the package to a text file.
+        /// </summary>
+        /// <param name="path">Path to write file.</param>
+        /// <param name="contentFilePaths">Collection of paths to content files that will be written to file.</param>
+        private void CreateContentsFile(string path, IEnumerable<string> contentFilePaths)
+        {
+            string directory = Path.GetDirectoryName(path);
+            if (!Directory.Exists(directory))
+            {
+                Directory.CreateDirectory(directory);
+            }
+
+            using (StreamWriter contents = new StreamWriter(path, false))
+            {
+                foreach (string contentPath in contentFilePaths)
+                {
+                    contents.WriteLine(contentPath);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Writes the paths to the content files included in the bundle to a text file.
+        /// </summary>
+        /// <param name="path">Path to write file.</param>
+        /// <param name="payloads">Collection of payloads whose source will be written to file.</param>
+        private void CreateContentsFile(string path, IEnumerable<WixBundlePayloadRow> payloads)
+        {
+            string directory = Path.GetDirectoryName(path);
+            if (!Directory.Exists(directory))
+            {
+                Directory.CreateDirectory(directory);
+            }
+
+            using (StreamWriter contents = new StreamWriter(path, false))
+            {
+                foreach (WixBundlePayloadRow payload in payloads)
+                {
+                    if (payload.ContentFile)
+                    {
+                        contents.WriteLine(payload.FullFileName);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Writes the paths to the output files to a text file.
+        /// </summary>
+        /// <param name="path">Path to write file.</param>
+        /// <param name="fileTransfers">Collection of files that were transferred to the output directory.</param>
+        /// <param name="pdbPath">Optional path to created .wixpdb.</param>
+        private void CreateOutputsFile(string path, IEnumerable<FileTransfer> fileTransfers, string pdbPath)
+        {
+            string directory = Path.GetDirectoryName(path);
+            if (!Directory.Exists(directory))
+            {
+                Directory.CreateDirectory(directory);
+            }
+
+            using (StreamWriter outputs = new StreamWriter(path, false))
+            {
+                foreach (FileTransfer fileTransfer in fileTransfers)
+                {
+                    // Don't list files where the source is the same as the destination since
+                    // that might be the only place the file exists. The outputs file is often
+                    // used to delete stuff and losing the original source would be bad.
+                    if (!fileTransfer.Redundant)
+                    {
+                        outputs.WriteLine(fileTransfer.Destination);
+                    }
+                }
+
+                if (!String.IsNullOrEmpty(pdbPath))
+                {
+                    outputs.WriteLine(Path.GetFullPath(pdbPath));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Writes the paths to the built output files to a text file.
+        /// </summary>
+        /// <param name="path">Path to write file.</param>
+        /// <param name="fileTransfers">Collection of files that were transferred to the output directory.</param>
+        /// <param name="pdbPath">Optional path to created .wixpdb.</param>
+        private void CreateBuiltOutputsFile(string path, IEnumerable<FileTransfer> fileTransfers, string pdbPath)
+        {
+            string directory = Path.GetDirectoryName(path);
+            if (!Directory.Exists(directory))
+            {
+                Directory.CreateDirectory(directory);
+            }
+
+            using (StreamWriter outputs = new StreamWriter(path, false))
+            {
+                foreach (FileTransfer fileTransfer in fileTransfers)
+                {
+                    // Only write the built file transfers. Also, skip redundant
+                    // files for the same reason spelled out in this.CreateOutputsFile().
+                    if (fileTransfer.Built && !fileTransfer.Redundant)
+                    {
+                        outputs.WriteLine(fileTransfer.Destination);
+                    }
+                }
+
+                if (!String.IsNullOrEmpty(pdbPath))
+                {
+                    outputs.WriteLine(Path.GetFullPath(pdbPath));
+                }
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/BinderCore.cs b/src/WixToolset.Core/BinderCore.cs
new file mode 100644
index 00000000..0feae0b2
--- /dev/null
+++ b/src/WixToolset.Core/BinderCore.cs
@@ -0,0 +1,58 @@
+// 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
+{
+    using WixToolset.Data;
+    using WixToolset.Extensibility;
+
+    /// <summary>
+    /// Core class for the binder.
+    /// </summary>
+    internal class BinderCore : IBinderCore
+    {
+        /// <summary>
+        /// Constructor for binder core.
+        /// </summary>
+        internal BinderCore()
+        {
+            this.TableDefinitions = new TableDefinitionCollection(WindowsInstallerStandard.GetTableDefinitions());
+        }
+
+        public IBinderFileManagerCore FileManagerCore { get; set; }
+
+        /// <summary>
+        /// Gets whether the binder core encountered an error while processing.
+        /// </summary>
+        /// <value>Flag if core encountered an error during processing.</value>
+        public bool EncounteredError
+        {
+            get { return Messaging.Instance.EncounteredError; }
+        }
+
+        /// <summary>
+        /// Gets the table definitions used by the Binder.
+        /// </summary>
+        /// <value>Table definitions used by the binder.</value>
+        public TableDefinitionCollection TableDefinitions { get; private set; }
+
+        /// <summary>
+        /// Generate an identifier by hashing data from the row.
+        /// </summary>
+        /// <param name="prefix">Three letter or less prefix for generated row identifier.</param>
+        /// <param name="args">Information to hash.</param>
+        /// <returns>The generated identifier.</returns>
+        public string CreateIdentifier(string prefix, params string[] args)
+        {
+            return Common.GenerateIdentifier(prefix, args);
+        }
+
+        /// <summary>
+        /// Sends a message to the message delegate if there is one.
+        /// </summary>
+        /// <param name="mea">Message event arguments.</param>
+        public void OnMessage(MessageEventArgs e)
+        {
+            Messaging.Instance.OnMessage(e);
+        }
+    }
+}
diff --git a/src/WixToolset.Core/BinderFileManager.cs b/src/WixToolset.Core/BinderFileManager.cs
new file mode 100644
index 00000000..0da54002
--- /dev/null
+++ b/src/WixToolset.Core/BinderFileManager.cs
@@ -0,0 +1,370 @@
+// 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
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics.CodeAnalysis;
+    using System.IO;
+    using System.Linq;
+    using System.Runtime.InteropServices;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+    using WixToolset.Extensibility;
+
+    /// <summary>
+    /// Base class for creating a binder file manager.
+    /// </summary>
+    public class BinderFileManager : IBinderFileManager
+    {
+        /// <summary>
+        /// Gets or sets the file manager core.
+        /// </summary>
+        public IBinderFileManagerCore Core { get; set; }
+
+        /// <summary>
+        /// Compares two files to determine if they are equivalent.
+        /// </summary>
+        /// <param name="targetFile">The target file.</param>
+        /// <param name="updatedFile">The updated file.</param>
+        /// <returns>true if the files are equal; false otherwise.</returns>
+        public virtual bool? CompareFiles(string targetFile, string updatedFile)
+        {
+            FileInfo targetFileInfo = new FileInfo(targetFile);
+            FileInfo updatedFileInfo = new FileInfo(updatedFile);
+
+            if (targetFileInfo.Length != updatedFileInfo.Length)
+            {
+                return false;
+            }
+
+            using (FileStream targetStream = File.OpenRead(targetFile))
+            {
+                using (FileStream updatedStream = File.OpenRead(updatedFile))
+                {
+                    if (targetStream.Length != updatedStream.Length)
+                    {
+                        return false;
+                    }
+
+                    // Using a larger buffer than the default buffer of 4 * 1024 used by FileStream.ReadByte improves performance.
+                    // The buffer size is based on user feedback. Based on performance results, a better buffer size may be determined.
+                    byte[] targetBuffer = new byte[16 * 1024];
+                    byte[] updatedBuffer = new byte[16 * 1024];
+                    int targetReadLength;
+                    int updatedReadLength;
+                    do
+                    {
+                        targetReadLength = targetStream.Read(targetBuffer, 0, targetBuffer.Length);
+                        updatedReadLength = updatedStream.Read(updatedBuffer, 0, updatedBuffer.Length);
+
+                        if (targetReadLength != updatedReadLength)
+                        {
+                            return false;
+                        }
+
+                        for (int i = 0; i < targetReadLength; ++i)
+                        {
+                            if (targetBuffer[i] != updatedBuffer[i])
+                            {
+                                return false;
+                            }
+                        }
+
+                    } while (0 < targetReadLength);
+                }
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Resolves the source path of a file.
+        /// </summary>
+        /// <param name="source">Original source value.</param>
+        /// <param name="type">Optional type of source file being resolved.</param>
+        /// <param name="sourceLineNumbers">Optional source line of source file being resolved.</param>
+        /// <param name="bindStage">The binding stage used to determine what collection of bind paths will be used</param>
+        /// <returns>Should return a valid path for the stream to be imported.</returns>
+        public virtual string ResolveFile(string source, string type, SourceLineNumber sourceLineNumbers, BindStage bindStage)
+        {
+            if (String.IsNullOrEmpty(source))
+            {
+                throw new ArgumentNullException("source");
+            }
+
+            if (BinderFileManager.CheckFileExists(source)) // if the file exists, we're good to go.
+            {
+                return source;
+            }
+            else if (Path.IsPathRooted(source)) // path is rooted so bindpaths won't help, bail since the file apparently doesn't exist.
+            {
+                return null;
+            }
+            else // not a rooted path so let's try applying all the different source resolution options.
+            {
+                const string bindPathOpenString = "!(bindpath.";
+
+                string bindName = String.Empty;
+                string path = source;
+                string pathWithoutSourceDir = null;
+
+                if (source.StartsWith(bindPathOpenString, StringComparison.Ordinal))
+                {
+                    int closeParen = source.IndexOf(')', bindPathOpenString.Length);
+                    if (-1 != closeParen)
+                    {
+                        bindName = source.Substring(bindPathOpenString.Length, closeParen - bindPathOpenString.Length);
+                        path = source.Substring(bindPathOpenString.Length + bindName.Length + 1); // +1 for the closing brace.
+                        path = path.TrimStart('\\'); // remove starting '\\' char so the path doesn't look rooted.
+                    }
+                }
+                else if (source.StartsWith("SourceDir\\", StringComparison.Ordinal) || source.StartsWith("SourceDir/", StringComparison.Ordinal))
+                {
+                    pathWithoutSourceDir = path.Substring(10);
+                }
+
+                var bindPaths = this.Core.GetBindPaths(bindStage, bindName);
+                foreach (string bindPath in bindPaths)
+                {
+                    string filePath;
+                    if (!String.IsNullOrEmpty(pathWithoutSourceDir))
+                    {
+                        filePath = Path.Combine(bindPath, pathWithoutSourceDir);
+                        if (BinderFileManager.CheckFileExists(filePath))
+                        {
+                            return filePath;
+                        }
+                    }
+
+                    filePath = Path.Combine(bindPath, path);
+                    if (BinderFileManager.CheckFileExists(filePath))
+                    {
+                        return filePath;
+                    }
+                }
+            }
+
+            // Didn't find the file.
+            return null;
+        }
+
+        /// <summary>
+        /// Resolves the source path of a file related to another file's source.
+        /// </summary>
+        /// <param name="source">Original source value.</param>
+        /// <param name="relatedSource">Source related to original source.</param>
+        /// <param name="type">Optional type of source file being resolved.</param>
+        /// <param name="sourceLineNumbers">Optional source line of source file being resolved.</param>
+        /// <param name="bindStage">The binding stage used to determine what collection of bind paths will be used</param>
+        /// <returns>Should return a valid path for the stream to be imported.</returns>
+        public virtual string ResolveRelatedFile(string source, string relatedSource, string type, SourceLineNumber sourceLineNumbers, BindStage bindStage)
+        {
+            string resolvedSource = this.ResolveFile(source, type, sourceLineNumbers, bindStage);
+            return Path.Combine(Path.GetDirectoryName(resolvedSource), relatedSource);
+        }
+
+        /// <summary>
+        /// Resolves the source path of a cabinet file.
+        /// </summary>
+        /// <param name="cabinetPath">Default path to cabinet to generate.</param>
+        /// <param name="filesWithPath">Collection of files in this cabinet.</param>
+        /// <returns>The CabinetBuildOption and path to build the .  By default the cabinet is built and moved to its target location.</returns>
+        [SuppressMessage("Microsoft.Design", "CA1045:DoNotPassTypesByReference")]
+        public virtual ResolvedCabinet ResolveCabinet(string cabinetPath, IEnumerable<BindFileWithPath> filesWithPath)
+        {
+            if (null == filesWithPath)
+            {
+                throw new ArgumentNullException("fileRows");
+            }
+
+            // By default cabinet should be built and moved to the suggested location.
+            ResolvedCabinet resolved = new ResolvedCabinet() { BuildOption = CabinetBuildOption.BuildAndMove, Path = cabinetPath };
+
+            // If a cabinet cache path was provided, change the location for the cabinet
+            // to be built to and check if there is a cabinet that can be reused.
+            if (!String.IsNullOrEmpty(this.Core.CabCachePath))
+            {
+                string cabinetName = Path.GetFileName(cabinetPath);
+                resolved.Path = Path.Combine(this.Core.CabCachePath, cabinetName);
+
+                if (BinderFileManager.CheckFileExists(resolved.Path))
+                {
+                    // Assume that none of the following are true:
+                    // 1. any files are added or removed
+                    // 2. order of files changed or names changed
+                    // 3. modified time changed
+                    bool cabinetValid = true;
+
+                    // Need to force garbage collection of WixEnumerateCab to ensure the handle
+                    // associated with it is closed before it is reused.
+                    using (Cab.WixEnumerateCab wixEnumerateCab = new Cab.WixEnumerateCab())
+                    {
+                        List<CabinetFileInfo> fileList = wixEnumerateCab.Enumerate(resolved.Path);
+
+                        if (filesWithPath.Count() != fileList.Count)
+                        {
+                            cabinetValid = false;
+                        }
+                        else
+                        {
+                            int i = 0;
+                            foreach (BindFileWithPath file in filesWithPath)
+                            {
+                                // First check that the file identifiers match because that is quick and easy.
+                                CabinetFileInfo cabFileInfo = fileList[i];
+                                cabinetValid = (cabFileInfo.FileId == file.Id);
+                                if (cabinetValid)
+                                {
+                                    // Still valid so ensure the file sizes are the same.
+                                    FileInfo fileInfo = new FileInfo(file.Path);
+                                    cabinetValid = (cabFileInfo.Size == fileInfo.Length);
+                                    if (cabinetValid)
+                                    {
+                                        // Still valid so ensure the source time stamp hasn't changed. Thus we need
+                                        // to convert the source file time stamp into a cabinet compatible data/time.
+                                        ushort sourceCabDate;
+                                        ushort sourceCabTime;
+
+                                        WixToolset.Core.Native.CabInterop.DateTimeToCabDateAndTime(fileInfo.LastWriteTime, out sourceCabDate, out sourceCabTime);
+                                        cabinetValid = (cabFileInfo.Date == sourceCabDate && cabFileInfo.Time == sourceCabTime);
+                                    }
+                                }
+
+                                if (!cabinetValid)
+                                {
+                                    break;
+                                }
+
+                                i++;
+                            }
+                        }
+                    }
+
+                    resolved.BuildOption = cabinetValid ? CabinetBuildOption.Copy : CabinetBuildOption.BuildAndCopy;
+                }
+            }
+
+            return resolved;
+        }
+
+        /// <summary>
+        /// Resolve the layout path of a media.
+        /// </summary>
+        /// <param name="mediaRow">The media's row.</param>
+        /// <param name="mediaLayoutDirectory">The layout directory provided by the Media element.</param>
+        /// <param name="layoutDirectory">The layout directory for the setup image.</param>
+        /// <returns>The layout path for the media.</returns>
+        public virtual string ResolveMedia(MediaRow mediaRow, string mediaLayoutDirectory, string layoutDirectory)
+        {
+            return null;
+        }
+
+        /// <summary>
+        /// Resolves the URL to a file.
+        /// </summary>
+        /// <param name="url">URL that may be a format string for the id and fileName.</param>
+        /// <param name="packageId">Identity of the package (if payload is not part of a package) the URL points to. NULL if not part of a package.</param>
+        /// <param name="payloadId">Identity of the payload the URL points to.</param>
+        /// <param name="fileName">File name the URL points at.</param>
+        /// <param name="fallbackUrl">Optional URL to use if the URL provided is empty.</param>
+        /// <returns>An absolute URL or null if no URL is provided.</returns>
+        public virtual string ResolveUrl(string url, string fallbackUrl, string packageId, string payloadId, string fileName)
+        {
+            // If a URL was not specified but there is a fallback URL that has a format specifier in it
+            // then use the fallback URL formatter for this URL.
+            if (String.IsNullOrEmpty(url) && !String.IsNullOrEmpty(fallbackUrl))
+            {
+                string formattedFallbackUrl = String.Format(fallbackUrl, packageId, payloadId, fileName);
+                if (!String.Equals(fallbackUrl, formattedFallbackUrl, StringComparison.OrdinalIgnoreCase))
+                {
+                    url = fallbackUrl;
+                }
+            }
+
+            if (!String.IsNullOrEmpty(url))
+            {
+                string formattedUrl = String.Format(url, packageId, payloadId, fileName);
+
+                Uri canonicalUri;
+                if (Uri.TryCreate(formattedUrl, UriKind.Absolute, out canonicalUri))
+                {
+                    url = canonicalUri.AbsoluteUri;
+                }
+                else
+                {
+                    url = null;
+                }
+            }
+
+            return url;
+        }
+
+        /// <summary>
+        /// Copies a file.
+        /// </summary>
+        /// <param name="source">The file to copy.</param>
+        /// <param name="destination">The destination file.</param>
+        /// <param name="overwrite">true if the destination file can be overwritten; otherwise, false.</param>
+        public virtual bool CopyFile(string source, string destination, bool overwrite)
+        {
+            if (overwrite && File.Exists(destination))
+            {
+                File.Delete(destination);
+            }
+
+            if (!CreateHardLink(destination, source, IntPtr.Zero))
+            {
+#if DEBUG
+                int er = Marshal.GetLastWin32Error();
+#endif
+
+                File.Copy(source, destination, overwrite);
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Moves a file.
+        /// </summary>
+        /// <param name="source">The file to move.</param>
+        /// <param name="destination">The destination file.</param>
+        public virtual bool MoveFile(string source, string destination, bool overwrite)
+        {
+            if (overwrite && File.Exists(destination))
+            {
+                File.Delete(destination);
+            }
+
+            var directory = Path.GetDirectoryName(destination);
+            if (!String.IsNullOrEmpty(directory))
+            {
+                Directory.CreateDirectory(directory);
+            }
+
+            File.Move(source, destination);
+            return true;
+        }
+
+        /// <summary>
+        /// Checks if a path exists, and throws a well known error for invalid paths.
+        /// </summary>
+        /// <param name="path">Path to check.</param>
+        /// <returns>True if path exists.</returns>
+        private static bool CheckFileExists(string path)
+        {
+            try
+            {
+                return File.Exists(path);
+            }
+            catch (ArgumentException)
+            {
+                throw new WixException(WixErrors.IllegalCharactersInPath(path));
+            }
+        }
+
+        [DllImport("Kernel32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+        private static extern bool CreateHardLink(string lpFileName, string lpExistingFileName, IntPtr lpSecurityAttributes);
+    }
+}
diff --git a/src/WixToolset.Core/BinderFileManagerCore.cs b/src/WixToolset.Core/BinderFileManagerCore.cs
new file mode 100644
index 00000000..6a5e1d5e
--- /dev/null
+++ b/src/WixToolset.Core/BinderFileManagerCore.cs
@@ -0,0 +1,108 @@
+// 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
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using WixToolset.Data;
+    using WixToolset.Extensibility;
+
+    public class BinderFileManagerCore : IBinderFileManagerCore
+    {
+        private Dictionary<string, List<string>>[] bindPaths;
+
+        /// <summary>
+        /// Instantiate a new BinderFileManager.
+        /// </summary>
+        public BinderFileManagerCore()
+        {
+            this.bindPaths = new Dictionary<string, List<string>>[3];
+            this.bindPaths[(int)BindStage.Normal] = new Dictionary<string, List<string>>();
+            this.bindPaths[(int)BindStage.Target] = new Dictionary<string, List<string>>();
+            this.bindPaths[(int)BindStage.Updated] = new Dictionary<string, List<string>>();
+        }
+
+        /// <summary>
+        /// Gets or sets the path to cabinet cache.
+        /// </summary>
+        /// <value>The path to cabinet cache.</value>
+        public string CabCachePath { get; set; }
+
+        /// <summary>
+        /// Gets or sets the active subStorage used for binding.
+        /// </summary>
+        /// <value>The subStorage object.</value>
+        public SubStorage ActiveSubStorage { get; set; }
+
+        /// <summary>
+        /// Gets or sets the output object used for binding.
+        /// </summary>
+        /// <value>The output object.</value>
+        public Output Output { get; set; }
+
+        /// <summary>
+        /// Gets or sets the path to the temp files location.
+        /// </summary>
+        /// <value>The path to the temp files location.</value>
+        public string TempFilesLocation { get; set; }
+
+        /// <summary>
+        /// Gets the property if re-basing target is true or false
+        /// </summary>
+        /// <value>It returns true if target bind path is to be replaced, otherwise false.</value>
+        public bool RebaseTarget
+        {
+            get { return this.bindPaths[(int)BindStage.Target].Any(); }
+        }
+
+        /// <summary>
+        /// Gets the property if re-basing updated build is true or false
+        /// </summary>
+        /// <value>It returns true if updated bind path is to be replaced, otherwise false.</value>
+        public bool RebaseUpdated
+        {
+            get { return this.bindPaths[(int)BindStage.Updated].Any(); }
+        }
+
+        public void AddBindPaths(IEnumerable<BindPath> paths, BindStage stage)
+        {
+            Dictionary<string, List<string>> dict = this.bindPaths[(int)stage];
+
+            foreach (BindPath bindPath in paths)
+            {
+                List<string> values;
+                if (!dict.TryGetValue(bindPath.Name, out values))
+                {
+                    values = new List<string>();
+                    dict.Add(bindPath.Name, values);
+                }
+
+                if (!values.Contains(bindPath.Path))
+                {
+                    values.Add(bindPath.Path);
+                }
+            }
+        }
+
+        public IEnumerable<string> GetBindPaths(BindStage stage = BindStage.Normal, string name = null)
+        {
+            List<string> paths;
+            if (this.bindPaths[(int)stage].TryGetValue(name ?? String.Empty, out paths))
+            {
+                return paths;
+            }
+
+            return Enumerable.Empty<string>();
+        }
+
+        /// <summary>
+        /// Sends a message to the message delegate if there is one.
+        /// </summary>
+        /// <param name="e">Message event arguments.</param>
+        public void OnMessage(MessageEventArgs e)
+        {
+            Messaging.Instance.OnMessage(e);
+        }
+    }
+}
diff --git a/src/WixToolset.Core/CLR/Interop/CLRInterop.cs b/src/WixToolset.Core/CLR/Interop/CLRInterop.cs
new file mode 100644
index 00000000..4157f23a
--- /dev/null
+++ b/src/WixToolset.Core/CLR/Interop/CLRInterop.cs
@@ -0,0 +1,147 @@
+// 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.Clr.Interop
+{
+    using System;
+    using System.Runtime.InteropServices;
+
+    /// <summary>
+    /// Interop class for mscorwks.dll assembly name APIs.
+    /// </summary>
+    internal sealed class ClrInterop
+    {
+        private static readonly Guid referenceIdentityGuid = new Guid("6eaf5ace-7917-4f3c-b129-e046a9704766");
+
+        /// <summary>
+        /// Protect the constructor.
+        /// </summary>
+        private ClrInterop()
+        {
+        }
+
+        /// <summary>
+        /// Represents a reference to the unique signature of a code object.
+        /// </summary>
+        [ComImport]
+        [Guid("6eaf5ace-7917-4f3c-b129-e046a9704766")]
+        [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+        internal interface IReferenceIdentity
+        {
+            /// <summary>
+            /// Get an assembly attribute.
+            /// </summary>
+            /// <param name="attributeNamespace">Attribute namespace.</param>
+            /// <param name="attributeName">Attribute name.</param>
+            /// <returns>The assembly attribute.</returns>
+            [return: MarshalAs(UnmanagedType.LPWStr)]
+            string GetAttribute(
+                [In, MarshalAs(UnmanagedType.LPWStr)] string attributeNamespace,
+                [In, MarshalAs(UnmanagedType.LPWStr)] string attributeName);
+
+            /// <summary>
+            /// Set an assembly attribute.
+            /// </summary>
+            /// <param name="attributeNamespace">Attribute namespace.</param>
+            /// <param name="attributeName">Attribute name.</param>
+            /// <param name="attributeValue">Attribute value.</param>
+            void SetAttribute(
+                [In, MarshalAs(UnmanagedType.LPWStr)] string attributeNamespace,
+                [In, MarshalAs(UnmanagedType.LPWStr)] string attributeName,
+                [In, MarshalAs(UnmanagedType.LPWStr)] string attributeValue);
+
+            /// <summary>
+            /// Get an iterator for the assembly's attributes.
+            /// </summary>
+            /// <returns>Assembly attribute enumerator.</returns>
+            IEnumIDENTITY_ATTRIBUTE EnumAttributes();
+
+            /// <summary>
+            /// Clone an IReferenceIdentity.
+            /// </summary>
+            /// <param name="countOfDeltas">Count of deltas.</param>
+            /// <param name="deltas">The deltas.</param>
+            /// <returns>Cloned IReferenceIdentity.</returns>
+            IReferenceIdentity Clone(
+                [In] IntPtr /*SIZE_T*/ countOfDeltas,
+                [In, MarshalAs(UnmanagedType.LPArray)] IDENTITY_ATTRIBUTE[] deltas);
+        }
+
+        /// <summary>
+        /// IEnumIDENTITY_ATTRIBUTE interface.
+        /// </summary>
+        [ComImport]
+        [Guid("9cdaae75-246e-4b00-a26d-b9aec137a3eb")]
+        [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+        internal interface IEnumIDENTITY_ATTRIBUTE
+        {
+            /// <summary>
+            /// Gets the next attributes.
+            /// </summary>
+            /// <param name="celt">Count of elements.</param>
+            /// <param name="attributes">Array of attributes being returned.</param>
+            /// <returns>The next attribute.</returns>
+            uint Next(
+                [In] uint celt,
+                [Out, MarshalAs(UnmanagedType.LPArray)] IDENTITY_ATTRIBUTE[] attributes);
+
+            /// <summary>
+            /// Copy the current attribute into a buffer.
+            /// </summary>
+            /// <param name="available">Number of available bytes.</param>
+            /// <param name="data">Buffer into which attribute should be written.</param>
+            /// <returns>Pointer to buffer containing the attribute.</returns>
+            IntPtr CurrentIntoBuffer(
+                [In] IntPtr /*SIZE_T*/ available,
+                [Out, MarshalAs(UnmanagedType.LPArray)] byte[] data);
+
+            /// <summary>
+            /// Skip past a number of elements.
+            /// </summary>
+            /// <param name="celt">Count of elements to skip.</param>
+            void Skip([In] uint celt);
+
+            /// <summary>
+            /// Reset the enumeration to the beginning.
+            /// </summary>
+            void Reset();
+
+            /// <summary>
+            /// Clone this attribute enumeration.
+            /// </summary>
+            /// <returns>Clone of a IEnumIDENTITY_ATTRIBUTE.</returns>
+            IEnumIDENTITY_ATTRIBUTE Clone();
+        }
+
+        /// <summary>
+        /// Gets the guid.
+        /// </summary>
+        public static Guid ReferenceIdentityGuid
+        {
+            get { return referenceIdentityGuid; }
+        }
+
+        /// <summary>
+        /// Gets an interface pointer to an object with the specified IID, in the assembly at the specified file path.
+        /// </summary>
+        /// <param name="wszAssemblyPath">A valid path to the requested assembly.</param>
+        /// <param name="riid">The IID of the interface to return.</param>
+        /// <param name="i">The returned interface pointer.</param>
+        /// <returns>The error code.</returns>
+        [DllImport("mscorwks.dll", CharSet = CharSet.Unicode, EntryPoint = "GetAssemblyIdentityFromFile")]
+        internal static extern uint GetAssemblyIdentityFromFile(System.String wszAssemblyPath, ref Guid riid, out IReferenceIdentity i);
+
+        /// <summary>
+        /// Assembly attributes. Contains data about an IReferenceIdentity.
+        /// </summary>
+        [StructLayout(LayoutKind.Sequential)]
+        internal struct IDENTITY_ATTRIBUTE
+        {
+            [MarshalAs(UnmanagedType.LPWStr)]
+            public string AttributeNamespace;
+            [MarshalAs(UnmanagedType.LPWStr)]
+            public string AttributeName;
+            [MarshalAs(UnmanagedType.LPWStr)]
+            public string AttributeValue;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Cab/CabinetFileInfo.cs b/src/WixToolset.Core/Cab/CabinetFileInfo.cs
new file mode 100644
index 00000000..849bb3bb
--- /dev/null
+++ b/src/WixToolset.Core/Cab/CabinetFileInfo.cs
@@ -0,0 +1,64 @@
+// 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
+{
+    using System;
+
+    /// <summary>
+    /// Properties of a file in a cabinet.
+    /// </summary>
+    internal sealed class CabinetFileInfo
+    {
+        private string fileId;
+        private ushort date;
+        private ushort time;
+        private int size;
+
+        /// <summary>
+        /// Constructs CabinetFileInfo
+        /// </summary>
+        /// <param name="fileId">File Id</param>
+        /// <param name="date">Last modified date (MS-DOS time)</param>
+        /// <param name="time">Last modified time (MS-DOS time)</param>
+        public CabinetFileInfo(string fileId, ushort date, ushort time, int size)
+        {
+            this.fileId = fileId;
+            this.date = date;
+            this.time = time;
+            this.size = size;
+        }
+
+        /// <summary>
+        /// Gets the file Id of the file.
+        /// </summary>
+        /// <value>file Id</value>
+        public string FileId
+        {
+            get { return this.fileId; }
+        }
+
+        /// <summary>
+        /// Gets modified date (DOS format).
+        /// </summary>
+        public ushort Date
+        {
+            get { return this.date; }
+        }
+
+        /// <summary>
+        /// Gets modified time (DOS format).
+        /// </summary>
+        public ushort Time
+        {
+            get { return this.time; }
+        }
+
+        /// <summary>
+        /// Gets the size of the file in bytes.
+        /// </summary>
+        public int Size
+        {
+            get { return this.size; }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Cab/Interop/CabInterop.cs b/src/WixToolset.Core/Cab/Interop/CabInterop.cs
new file mode 100644
index 00000000..6c1ae2c1
--- /dev/null
+++ b/src/WixToolset.Core/Cab/Interop/CabInterop.cs
@@ -0,0 +1,316 @@
+// 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.
+
+#if false
+
+namespace WixToolset.Cab.Interop
+{
+    using System;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Text;
+    using System.Runtime.InteropServices;
+    using WixToolset.Msi;
+    using WixToolset.Msi.Interop;
+
+    /// <summary>
+    /// The native methods.
+    /// </summary>
+    public sealed class NativeMethods
+    {
+        /// <summary>
+        /// Starts creating a cabinet.
+        /// </summary>
+        /// <param name="cabinetName">Name of cabinet to create.</param>
+        /// <param name="cabinetDirectory">Directory to create cabinet in.</param>
+        /// <param name="maxFiles">Maximum number of files that will be added to cabinet.</param>
+        /// <param name="maxSize">Maximum size of the cabinet.</param>
+        /// <param name="maxThreshold">Maximum threshold in the cabinet.</param>
+        /// <param name="compressionType">Type of compression to use in the cabinet.</param>
+        /// <param name="contextHandle">Handle to opened cabinet.</param>
+        [DllImport("winterop.dll", EntryPoint = "CreateCabBegin", CharSet = CharSet.Unicode, ExactSpelling = true, PreserveSig = false)]
+        internal static extern void CreateCabBegin(string cabinetName, string cabinetDirectory, uint maxFiles, uint maxSize, uint maxThreshold, uint compressionType, out IntPtr contextHandle);
+
+        /// <summary>
+        /// Adds a file to an open cabinet.
+        /// </summary>
+        /// <param name="file">Full path to file to add to cabinet.</param>
+        /// <param name="token">Name of file in cabinet.</param>
+        /// <param name="contextHandle">Handle to open cabinet.</param>
+        [DllImport("winterop.dll", EntryPoint = "CreateCabAddFile", CharSet = CharSet.Unicode, ExactSpelling = true, PreserveSig = false)]
+        internal static extern void CreateCabAddFile(string file, string token, MsiInterop.MSIFILEHASHINFO fileHash, IntPtr contextHandle);
+
+        /// <summary>
+        /// Closes a cabinet.
+        /// </summary>
+        /// <param name="contextHandle">Handle to open cabinet to close.</param>
+        /// <param name="newCabNamesCallBackAddress">Address of Binder's cabinet split callback</param>
+        [DllImport("winterop.dll", EntryPoint = "CreateCabFinish", CharSet = CharSet.Unicode, ExactSpelling = true, PreserveSig = false)]
+        internal static extern void CreateCabFinish(IntPtr contextHandle, IntPtr newCabNamesCallBackAddress);
+
+        /// <summary>
+        /// Cancels cabinet creation.
+        /// </summary>
+        /// <param name="contextHandle">Handle to open cabinet to cancel.</param>
+        [DllImport("winterop.dll", EntryPoint = "CreateCabCancel", CharSet = CharSet.Unicode, ExactSpelling = true, PreserveSig = false)]
+        internal static extern void CreateCabCancel(IntPtr contextHandle);
+
+        /// <summary>
+        /// Initializes cabinet extraction.
+        /// </summary>
+        [DllImport("winterop.dll", EntryPoint = "ExtractCabBegin", CharSet = CharSet.Unicode, ExactSpelling = true, PreserveSig = false)]
+        internal static extern void ExtractCabBegin();
+
+        /// <summary>
+        /// Extracts files from cabinet.
+        /// </summary>
+        /// <param name="cabinet">Path to cabinet to extract files from.</param>
+        /// <param name="extractDirectory">Directory to extract files to.</param>
+        [DllImport("winterop.dll", EntryPoint = "ExtractCab", CharSet = CharSet.Unicode, ExactSpelling = true, SetLastError = true, PreserveSig = false)]
+        internal static extern void ExtractCab(string cabinet, string extractDirectory);
+
+        /// <summary>
+        /// Cleans up after cabinet extraction.
+        /// </summary>
+        [DllImport("winterop.dll", EntryPoint = "ExtractCabFinish", CharSet = CharSet.Unicode, ExactSpelling = true, SetLastError = true)]
+        internal static extern void ExtractCabFinish();
+
+        /// <summary>
+        /// Initializes cabinet enumeration.
+        /// </summary>
+        [DllImport("winterop.dll", EntryPoint = "EnumerateCabBegin", CharSet = CharSet.Unicode, ExactSpelling = true, PreserveSig = false)]
+        internal static extern void EnumerateCabBegin();
+
+        /// <summary>
+        /// Enumerates files from cabinet.
+        /// </summary>
+        /// <param name="cabinet">Path to cabinet to enumerate files from.</param>
+        /// <param name="notify">callback that gets each file.</param>
+        [DllImport("winterop.dll", EntryPoint = "EnumerateCab", CharSet = CharSet.Unicode, ExactSpelling = true, SetLastError = true, PreserveSig = false)]
+        internal static extern void EnumerateCab(string cabinet, CabInterop.PFNNOTIFY notify);
+
+        /// <summary>
+        /// Cleans up after cabinet enumeration.
+        /// </summary>
+        [DllImport("winterop.dll", EntryPoint = "EnumerateCabFinish", CharSet = CharSet.Unicode, ExactSpelling = true, SetLastError = true)]
+        internal static extern void EnumerateCabFinish();
+
+        /// <summary>
+        /// Resets the DACL on an array of files to "empty".
+        /// </summary>
+        /// <param name="files">Array of file reset ACL to "empty".</param>
+        /// <param name="fileCount">Number of file paths in array.</param>
+        [DllImport("winterop.dll", EntryPoint = "ResetAcls", CharSet = CharSet.Unicode, ExactSpelling = true, PreserveSig = false)]
+        internal static extern void ResetAcls(string[] files, uint fileCount);
+
+        /// <summary>
+        /// Gets the hash of the pCertContext->pCertInfo->SubjectPublicKeyInfo using ::CryptHashPublicKeyInfo() which does not seem
+        /// to be exposed by .NET Frameowkr.
+        /// </summary>
+        /// <param name="certContext">Pointer to a CERT_CONTEXT struct with public key information to hash.</param>
+        /// <param name="fileCount">Number of file paths in array.</param>
+        [DllImport("winterop.dll", EntryPoint = "HashPublicKeyInfo", CharSet = CharSet.Unicode, ExactSpelling = true, PreserveSig = false)]
+        internal static extern void HashPublicKeyInfo(IntPtr certContext, byte[] publicKeyInfoHashed, ref uint sizePublicKeyInfoHashed);
+
+        /// <summary>
+        /// Converts file time to a local file time.
+        /// </summary>
+        /// <param name="fileTime">file time</param>
+        /// <param name="localTime">local file time</param>
+        /// <returns>true if successful, false otherwise</returns>
+        [DllImport("kernel32.dll", SetLastError = true)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static extern bool FileTimeToLocalFileTime(ref long fileTime, ref long localTime);
+
+        /// <summary>
+        /// Converts file time to a MS-DOS time.
+        /// </summary>
+        /// <param name="fileTime">file time</param>
+        /// <param name="wFatDate">MS-DOS date</param>
+        /// <param name="wFatTime">MS-DOS time</param>
+        /// <returns>true if successful, false otherwise</returns>
+        [DllImport("kernel32.dll", SetLastError = true)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static extern bool FileTimeToDosDateTime(ref long fileTime, out ushort wFatDate, out ushort wFatTime);
+    }
+
+    /// <summary>
+    /// Interop class for the winterop.dll.
+    /// </summary>
+    internal static class CabInterop
+    {
+        /// <summary>
+        /// Delegate type that's called by cabinet api for every file in cabinet.
+        /// </summary>
+        /// <param name="fdint">NOTIFICATIONTYPE</param>
+        /// <param name="pfdin">NOTIFICATION</param>
+        /// <returns>0 for success, -1 otherwise</returns>
+        public delegate Int32 PFNNOTIFY(NOTIFICATIONTYPE fdint, NOTIFICATION pfdin);
+
+        /// <summary>
+        /// Wraps FDINOTIFICATIONTYPE.
+        /// </summary>
+        public enum NOTIFICATIONTYPE : int
+        {
+            /// <summary>Info about the cabinet.</summary>
+            CABINET_INFO,
+            /// <summary>One or more files are continued.</summary>
+            PARTIAL_FILE,
+            /// <summary>Called for each file in cabinet.</summary>
+            COPY_FILE,
+            /// <summary>Called after all of the data has been written to a target file.</summary>
+            CLOSE_FILE_INFO,
+            /// <summary>A file is continued to the next cabinet.</summary>
+            NEXT_CABINET,
+            /// <summary>Called once after a call to FDICopy() starts scanning a CAB's CFFILE entries, and again when there are no more CFFILE entries.</summary>
+            ENUMERATE,
+        }
+
+        /// <summary>
+        /// Converts DateTime to MS-DOS date and time which cabinet uses.
+        /// </summary>
+        /// <param name="dateTime">DateTime</param>
+        /// <param name="cabDate">MS-DOS date</param>
+        /// <param name="cabTime">MS-DOS time</param>
+        public static void DateTimeToCabDateAndTime(DateTime dateTime, out ushort cabDate, out ushort cabTime)
+        {
+            // dateTime.ToLocalTime() does not match FileTimeToLocalFileTime() for some reason.
+            // so we need to call FileTimeToLocalFileTime() from kernel32.dll.
+            long filetime = dateTime.ToFileTime();
+            long localTime = 0;
+            NativeMethods.FileTimeToLocalFileTime(ref filetime, ref localTime);
+            NativeMethods.FileTimeToDosDateTime(ref localTime, out cabDate, out cabTime);
+        }
+
+        /// <summary>
+        /// Wraps FDINOTIFICATION.
+        /// </summary>
+        [SuppressMessage("Microsoft.Performance", "CA1812:AvoidUninstantiatedInternalClasses")]
+        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
+        public class NOTIFICATION
+        {
+            private int cb;
+            [MarshalAs(UnmanagedType.LPStr)]
+            private string psz1;
+            [MarshalAs(UnmanagedType.LPStr)]
+            private string psz2;
+            [MarshalAs(UnmanagedType.LPStr)]
+            private string psz3;
+            private IntPtr pv;
+
+            private IntPtr hf;
+
+            private ushort date;
+            private ushort time;
+            private ushort attribs;
+            private ushort setID;
+            private ushort cabinet;
+            private ushort folder;
+            private int fdie;
+
+            /// <summary>
+            /// Uncompressed size of file.
+            /// </summary>
+            public int Cb
+            {
+                get { return this.cb; }
+            }
+
+            /// <summary>
+            /// File name in cabinet.
+            /// </summary>
+            public String Psz1 
+            { 
+                get { return this.psz1; } 
+            }
+
+            /// <summary>
+            /// Name of next disk.
+            /// </summary>
+            public string Psz2 
+            { 
+                get { return this.psz2; } 
+            }
+
+            /// <summary>
+            /// Points to a 256 character buffer.
+            /// </summary>
+            public string Psz3 
+            {
+                get { return this.psz3; } 
+            }
+
+            /// <summary>
+            /// Value for client.
+            /// </summary>
+            public IntPtr Pv 
+            { 
+                get { return this.pv; } 
+            }
+
+            /// <summary>
+            /// Not used.
+            /// </summary>
+            public Int32 Hf 
+            { 
+                get { return (Int32)this.hf; }
+            }
+
+            /// <summary>
+            /// Last modified MS-DOS date.
+            /// </summary>
+            public ushort Date 
+            { 
+                get { return this.date; } 
+            }
+
+            /// <summary>
+            /// Last modified MS-DOS time.
+            /// </summary>
+            public ushort Time 
+            { 
+                get { return this.time; } 
+            }
+
+            /// <summary>
+            /// File attributes.
+            /// </summary>
+            public ushort Attribs 
+            { 
+                get { return this.attribs; } 
+            }
+
+            /// <summary>
+            /// Cabinet set ID (a random 16-bit number).
+            /// </summary>
+            public ushort SetID 
+            {
+                get { return this.setID; } 
+            }
+
+            /// <summary>
+            /// Cabinet number within cabinet set (0-based).
+            /// </summary>
+            public ushort Cabinet 
+            { 
+                get { return this.cabinet; } 
+            }
+
+            /// <summary>
+            /// File's folder index.
+            /// </summary>
+            public ushort Folder 
+            { 
+                get { return this.folder; } 
+            }
+
+            /// <summary>
+            /// Error code.
+            /// </summary>
+            public int Fdie 
+            { 
+                get { return this.fdie; } 
+            }
+        }
+    }
+}
+
+#endif
diff --git a/src/WixToolset.Core/Cab/WixCreateCab.cs b/src/WixToolset.Core/Cab/WixCreateCab.cs
new file mode 100644
index 00000000..8f985a43
--- /dev/null
+++ b/src/WixToolset.Core/Cab/WixCreateCab.cs
@@ -0,0 +1,249 @@
+// 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.Cab
+{
+    using System;
+    using System.Globalization;
+    using System.IO;
+    using System.Runtime.InteropServices;
+    using WixToolset.Bind.Databases;
+    using WixToolset.Core.Native;
+    using WixToolset.Data;
+
+    /// <summary>
+    /// Wrapper class around interop with wixcab.dll to compress files into a cabinet.
+    /// </summary>
+    public sealed class WixCreateCab : IDisposable
+    {
+        private static readonly string CompressionLevelVariable = "WIX_COMPRESSION_LEVEL";
+        private IntPtr handle = IntPtr.Zero;
+        private bool disposed;
+        private int maxSize;
+
+        /// <summary>
+        /// Creates a cabinet.
+        /// </summary>
+        /// <param name="cabName">Name of cabinet to create.</param>
+        /// <param name="cabDir">Directory to create cabinet in.</param>
+        /// <param name="maxFiles">Maximum number of files that will be added to cabinet.</param>
+        /// <param name="maxSize">Maximum size of cabinet.</param>
+        /// <param name="maxThresh">Maximum threshold for each cabinet.</param>
+        /// <param name="compressionLevel">Level of compression to apply.</param>
+        public WixCreateCab(string cabName, string cabDir, int maxFiles, int maxSize, int maxThresh, CompressionLevel compressionLevel)
+        {
+            string compressionLevelVariable = Environment.GetEnvironmentVariable(CompressionLevelVariable);
+            this.maxSize = maxSize;
+
+            try
+            {
+                // Override authored compression level if environment variable is present.
+                if (!String.IsNullOrEmpty(compressionLevelVariable))
+                {
+                    compressionLevel = WixCreateCab.CompressionLevelFromString(compressionLevelVariable);
+                }
+            }
+            catch (WixException)
+            {
+                throw new WixException(WixErrors.IllegalEnvironmentVariable(CompressionLevelVariable, compressionLevelVariable));
+            }
+
+            if (String.IsNullOrEmpty(cabDir))
+            {
+                cabDir = Directory.GetCurrentDirectory();
+            }
+
+            try
+            {
+                NativeMethods.CreateCabBegin(cabName, cabDir, (uint)maxFiles, (uint)maxSize, (uint)maxThresh, (uint)compressionLevel, out this.handle);
+            }
+            catch (COMException ce)
+            {
+                // If we get a "the file exists" error, we must have a full temp directory - so report the issue
+                if (0x80070050 == unchecked((uint)ce.ErrorCode))
+                {
+                    throw new WixException(WixErrors.FullTempDirectory("WSC", Path.GetTempPath()));
+                }
+
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Destructor for cabinet creation.
+        /// </summary>
+        ~WixCreateCab()
+        {
+            this.Dispose();
+        }
+
+        /// <summary>
+        /// Converts a compression level from its string to its enum value.
+        /// </summary>
+        /// <param name="compressionLevel">Compression level as a string.</param>
+        /// <returns>CompressionLevel enum value</returns>
+        public static CompressionLevel CompressionLevelFromString(string compressionLevel)
+        {
+            switch (compressionLevel.ToLower(CultureInfo.InvariantCulture))
+            {
+                case "low":
+                    return CompressionLevel.Low;
+                case "medium":
+                    return CompressionLevel.Medium;
+                case "high":
+                    return CompressionLevel.High;
+                case "none":
+                    return CompressionLevel.None;
+                case "mszip":
+                    return CompressionLevel.Mszip;
+                default:
+                    throw new WixException(WixErrors.IllegalCompressionLevel(compressionLevel));
+            }
+        }
+
+        /// <summary>
+        /// Adds a file to the cabinet.
+        /// </summary>
+        /// <param name="fileFacade">The file facade of the file to add.</param>
+        public void AddFile(FileFacade fileFacade)
+        {
+            MsiInterop.MSIFILEHASHINFO hashInterop = new MsiInterop.MSIFILEHASHINFO();
+
+            if (null != fileFacade.Hash)
+            {
+                hashInterop.FileHashInfoSize = 20;
+                hashInterop.Data0 = (int)fileFacade.Hash[2];
+                hashInterop.Data1 = (int)fileFacade.Hash[3];
+                hashInterop.Data2 = (int)fileFacade.Hash[4];
+                hashInterop.Data3 = (int)fileFacade.Hash[5];
+
+                this.AddFile(fileFacade.WixFile.Source, fileFacade.File.File, hashInterop);
+            }
+            else
+            {
+                this.AddFile(fileFacade.WixFile.Source, fileFacade.File.File);
+            }
+        }
+
+        /// <summary>
+        /// Adds a file to the cabinet.
+        /// </summary>
+        /// <param name="file">The file to add.</param>
+        /// <param name="token">The token for the file.</param>
+        public void AddFile(string file, string token)
+        {
+            this.AddFile(file, token, null);
+        }
+
+        /// <summary>
+        /// Adds a file to the cabinet with an optional MSI file hash.
+        /// </summary>
+        /// <param name="file">The file to add.</param>
+        /// <param name="token">The token for the file.</param>
+        /// <param name="fileHash">The MSI file hash of the file.</param>
+        private void AddFile(string file, string token, MsiInterop.MSIFILEHASHINFO fileHash)
+        {
+            try
+            {
+                NativeMethods.CreateCabAddFile(file, token, fileHash, this.handle);
+            }
+            catch (COMException ce)
+            {
+                if (0x80004005 == unchecked((uint)ce.ErrorCode)) // E_FAIL
+                {
+                    throw new WixException(WixErrors.CreateCabAddFileFailed());
+                }
+                else if (0x80070070 == unchecked((uint)ce.ErrorCode)) // ERROR_DISK_FULL
+                {
+                    throw new WixException(WixErrors.CreateCabInsufficientDiskSpace());
+                }
+                else
+                {
+                    throw;
+                }
+            }
+            catch (DirectoryNotFoundException)
+            {
+                throw new WixFileNotFoundException(file);
+            }
+            catch (FileNotFoundException)
+            {
+                throw new WixFileNotFoundException(file);
+            }
+        }
+
+        /// <summary>
+        /// Complete/commit the cabinet - this must be called before Dispose so that errors will be
+        /// reported on the same thread.
+        /// This Complete should be used with no Cabinet splitting as it has the split cabinet names callback address as Zero
+        /// </summary>
+        public void Complete()
+        {
+            this.Complete(IntPtr.Zero);
+        }
+
+        /// <summary>
+        /// Complete/commit the cabinet - this must be called before Dispose so that errors will be
+        /// reported on the same thread.
+        /// </summary>
+        /// <param name="newCabNamesCallBackAddress">Address of Binder's callback function for Cabinet Splitting</param>
+        public void Complete(IntPtr newCabNamesCallBackAddress)
+        {
+            if (IntPtr.Zero != this.handle)
+            {
+                try
+                {
+                    if (newCabNamesCallBackAddress != IntPtr.Zero && this.maxSize != 0)
+                    {
+                        NativeMethods.CreateCabFinish(this.handle, newCabNamesCallBackAddress);
+                    }
+                    else
+                    {
+                        NativeMethods.CreateCabFinish(this.handle, IntPtr.Zero);
+                    }
+
+                    GC.SuppressFinalize(this);
+                    this.disposed = true;
+                }
+                catch (COMException ce)
+                {
+                    if (0x80004005 == unchecked((uint)ce.ErrorCode)) // E_FAIL
+                    {
+                        // This error seems to happen, among other situations, when cabbing more than 0xFFFF files
+                        throw new WixException(WixErrors.FinishCabFailed());
+                    }
+                    else if (0x80070070 == unchecked((uint)ce.ErrorCode)) // ERROR_DISK_FULL
+                    {
+                        throw new WixException(WixErrors.CreateCabInsufficientDiskSpace());
+                    }
+                    else
+                    {
+                        throw;
+                    }
+                }
+                finally
+                {
+                    this.handle = IntPtr.Zero;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Cancels ("rolls back") the creation of the cabinet.
+        /// Don't throw WiX errors from here, because we're in a different thread, and they won't be reported correctly.
+        /// </summary>
+        public void Dispose()
+        {
+            if (!this.disposed)
+            {
+                if (IntPtr.Zero != this.handle)
+                {
+                    NativeMethods.CreateCabCancel(this.handle);
+                    this.handle = IntPtr.Zero;
+                }
+
+                GC.SuppressFinalize(this);
+                this.disposed = true;
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Cab/WixEnumerateCab.cs b/src/WixToolset.Core/Cab/WixEnumerateCab.cs
new file mode 100644
index 00000000..017eeffb
--- /dev/null
+++ b/src/WixToolset.Core/Cab/WixEnumerateCab.cs
@@ -0,0 +1,89 @@
+// 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.Cab
+{
+    using System;
+    using System.Collections.Generic;
+    using WixToolset.Core.Native;
+    using Handle = System.Int32;
+
+    /// <summary>
+    /// Wrapper class around interop with wixcab.dll to enumerate files from a cabinet.
+    /// </summary>
+    internal sealed class WixEnumerateCab : IDisposable
+    {
+        private bool disposed;
+        private List<CabinetFileInfo> fileInfoList;
+        private CabInterop.PFNNOTIFY pfnNotify;
+
+        /// <summary>
+        /// Creates a cabinet enumerator.
+        /// </summary>
+        public WixEnumerateCab()
+        {
+            this.pfnNotify = new CabInterop.PFNNOTIFY(this.Notify);
+            NativeMethods.EnumerateCabBegin();
+        }
+
+        /// <summary>
+        /// Destructor for cabinet enumeration.
+        /// </summary>
+        ~WixEnumerateCab()
+        {
+            this.Dispose();
+        }
+
+        /// <summary>
+        /// Enumerates all files in a cabinet.
+        /// </summary>
+        /// <param name="cabinetFile">path to cabinet</param>
+        /// <returns>list of CabinetFileInfo</returns>
+        internal List<CabinetFileInfo> Enumerate(string cabinetFile)
+        {
+            this.fileInfoList = new List<CabinetFileInfo>();
+
+            // the callback (this.Notify) will populate the list for each file in cabinet
+            NativeMethods.EnumerateCab(cabinetFile, this.pfnNotify);
+
+            return this.fileInfoList;
+        }
+
+        /// <summary>
+        /// Disposes the managed and unmanaged objects in this object.
+        /// </summary>
+        public void Dispose()
+        {
+            if (!this.disposed)
+            {
+                NativeMethods.EnumerateCabFinish();
+
+                GC.SuppressFinalize(this);
+                this.disposed = true;
+            }
+        }
+
+        /// <summary>
+        /// Delegate that's called for every file in cabinet.
+        /// </summary>
+        /// <param name="fdint">NOTIFICATIONTYPE</param>
+        /// <param name="pfdin">NOTIFICATION</param>
+        /// <returns>System.Int32</returns>
+        internal Handle Notify(CabInterop.NOTIFICATIONTYPE fdint, CabInterop.NOTIFICATION pfdin)
+        {
+            // This is FDI's way of notifying us of how many files total are in the cab, accurate even
+            // if the files are split into multiple folders - use it to allocate the precise size we need
+            if (CabInterop.NOTIFICATIONTYPE.ENUMERATE == fdint && 0 == this.fileInfoList.Count)
+            {
+                this.fileInfoList.Capacity = pfdin.Folder;
+            }
+
+            if (fdint == CabInterop.NOTIFICATIONTYPE.COPY_FILE)
+            {
+                CabinetFileInfo fileInfo = new CabinetFileInfo(pfdin.Psz1, pfdin.Date, pfdin.Time, pfdin.Cb);
+                this.fileInfoList.Add(fileInfo);
+            }
+
+            return 0; // tell cabinet api to skip this file.
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Cab/WixExtractCab.cs b/src/WixToolset.Core/Cab/WixExtractCab.cs
new file mode 100644
index 00000000..debdaf15
--- /dev/null
+++ b/src/WixToolset.Core/Cab/WixExtractCab.cs
@@ -0,0 +1,76 @@
+// 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.Cab
+{
+    using System;
+    using System.Runtime.InteropServices;
+    using WixToolset.Core.Native;
+
+    /// <summary>
+    /// Wrapper class around interop with wixcab.dll to extract files from a cabinet.
+    /// </summary>
+    public sealed class WixExtractCab : IDisposable
+    {
+        private bool disposed;
+
+        /// <summary>
+        /// Creates a cabinet extractor.
+        /// </summary>
+        public WixExtractCab()
+        {
+            NativeMethods.ExtractCabBegin();
+        }
+
+        /// <summary>
+        /// Destructor for cabinet extraction.
+        /// </summary>
+        ~WixExtractCab()
+        {
+            this.Dispose();
+        }
+
+        /// <summary>
+        /// Extracts all the files from a cabinet to a directory.
+        /// </summary>
+        /// <param name="cabinetFile">Cabinet file to extract from.</param>
+        /// <param name="extractDir">Directory to extract files to.</param>
+        public void Extract(string cabinetFile, string extractDir)
+        {
+            if (null == cabinetFile)
+            {
+                throw new ArgumentNullException("cabinetFile");
+            }
+
+            if (null == extractDir)
+            {
+                throw new ArgumentNullException("extractDir");
+            }
+
+            if (this.disposed)
+            {
+                throw new ObjectDisposedException("WixExtractCab");
+            }
+
+            if (!extractDir.EndsWith("\\", StringComparison.Ordinal))
+            {
+                extractDir = String.Concat(extractDir, "\\");
+            }
+
+            NativeMethods.ExtractCab(cabinetFile, extractDir);
+        }
+
+        /// <summary>
+        /// Disposes the managed and unmanaged objects in this object.
+        /// </summary>
+        public void Dispose()
+        {
+            if (!this.disposed)
+            {
+                NativeMethods.ExtractCabFinish();
+
+                GC.SuppressFinalize(this);
+                this.disposed = true;
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/CommandLine/BuildCommand.cs b/src/WixToolset.Core/CommandLine/BuildCommand.cs
new file mode 100644
index 00000000..ffb48305
--- /dev/null
+++ b/src/WixToolset.Core/CommandLine/BuildCommand.cs
@@ -0,0 +1,100 @@
+// 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.Core
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Linq;
+    using WixToolset.Data;
+
+    internal class BuildCommand : ICommand
+    {
+        public BuildCommand(IEnumerable<SourceFile> sources, IDictionary<string, string> preprocessorVariables, IEnumerable<string> locFiles, string outputPath, IEnumerable<string> cultures, string contentsFile, string outputsFile, string builtOutputsFile, string wixProjectFile)
+        {
+            this.LocFiles = locFiles;
+            this.PreprocessorVariables = preprocessorVariables;
+            this.SourceFiles = sources;
+            this.OutputPath = outputPath;
+
+            this.Cultures = cultures;
+            this.ContentsFile = contentsFile;
+            this.OutputsFile = outputsFile;
+            this.BuiltOutputsFile = builtOutputsFile;
+            this.WixProjectFile = wixProjectFile;
+        }
+
+        public IEnumerable<string> LocFiles { get; }
+
+        private IEnumerable<SourceFile> SourceFiles { get; }
+
+        private IDictionary<string, string> PreprocessorVariables { get; }
+
+        private string OutputPath { get; }
+
+        public IEnumerable<string> Cultures { get; }
+
+        public string ContentsFile { get; }
+
+        public string OutputsFile { get; }
+
+        public string BuiltOutputsFile { get; }
+
+        public string WixProjectFile { get; }
+
+        public int Execute()
+        {
+            var intermediates = CompilePhase();
+
+            var sections = intermediates.SelectMany(i => i.Sections).ToList();
+
+            var linker = new Linker();
+
+            var output = linker.Link(sections, OutputType.Product);
+
+            var localizer = new Localizer();
+
+            var binder = new Binder();
+            binder.TempFilesLocation = Path.GetTempPath();
+            binder.WixVariableResolver = new WixVariableResolver();
+            binder.WixVariableResolver.Localizer = localizer;
+            binder.AddExtension(new BinderFileManager());
+            binder.SuppressValidation = true;
+
+            binder.ContentsFile = this.ContentsFile;
+            binder.OutputsFile = this.OutputsFile;
+            binder.BuiltOutputsFile = this.BuiltOutputsFile;
+            binder.WixprojectFile = this.WixProjectFile;
+
+            foreach (var loc in this.LocFiles)
+            {
+                var localization = Localizer.ParseLocalizationFile(loc, linker.TableDefinitions);
+                binder.WixVariableResolver.Localizer.AddLocalization(localization);
+            }
+
+            binder.Bind(output, this.OutputPath);
+
+            return 0;
+        }
+
+        private IEnumerable<Intermediate> CompilePhase()
+        {
+            var intermediates = new List<Intermediate>();
+
+            var preprocessor = new Preprocessor();
+
+            var compiler = new Compiler();
+
+            foreach (var sourceFile in this.SourceFiles)
+            {
+                var document = preprocessor.Process(sourceFile.SourcePath, this.PreprocessorVariables);
+
+                var intermediate = compiler.Compile(document);
+
+                intermediates.Add(intermediate);
+            }
+
+            return intermediates;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/CommandLine/CommandLine.cs b/src/WixToolset.Core/CommandLine/CommandLine.cs
new file mode 100644
index 00000000..440ae9ef
--- /dev/null
+++ b/src/WixToolset.Core/CommandLine/CommandLine.cs
@@ -0,0 +1,592 @@
+// 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.Core
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Linq;
+    using System.Text;
+    using System.Text.RegularExpressions;
+    using WixToolset.Data;
+    using WixToolset.Extensibility;
+
+    internal enum Commands
+    {
+        Unknown,
+        Build,
+        Preprocess,
+        Compile,
+        Link,
+        Bind,
+    }
+
+    public class CommandLine
+    {
+        private CommandLine()
+        {
+        }
+
+        public static string ExpectedArgument { get; } = "expected argument";
+
+        public string ActiveCommand { get; private set; }
+
+        public string[] OriginalArguments { get; private set; }
+
+        public Queue<string> RemainingArguments { get; } = new Queue<string>();
+
+        public ExtensionManager ExtensionManager { get; } = new ExtensionManager();
+
+        public string ErrorArgument { get; set; }
+
+        public bool ShowHelp { get; set; }
+
+        public static ICommand ParseStandardCommandLine(string commandLineString)
+        {
+            var args = CommandLine.ParseArgumentsToArray(commandLineString).ToArray();
+
+            return ParseStandardCommandLine(args);
+        }
+
+        public static ICommand ParseStandardCommandLine(string[] args)
+        {
+            var next = String.Empty;
+
+            var command = Commands.Unknown;
+            var showLogo = true;
+            var showVersion = false;
+            var outputFolder = String.Empty;
+            var outputFile = String.Empty;
+            var sourceFile = String.Empty;
+            var verbose = false;
+            var files = new List<string>();
+            var defines = new List<string>();
+            var includePaths = new List<string>();
+            var locFiles = new List<string>();
+            var suppressedWarnings = new List<int>();
+
+            var cultures = new List<string>();
+            var contentsFile = String.Empty;
+            var outputsFile = String.Empty;
+            var builtOutputsFile = String.Empty;
+            var wixProjectFile = String.Empty;
+
+            var cli = CommandLine.Parse(args, (cmdline, arg) => Enum.TryParse(arg, true, out command), (cmdline, arg) =>
+            {
+                if (cmdline.IsSwitch(arg))
+                {
+                    var parameter = arg.TrimStart(new[] { '-', '/' });
+                    switch (parameter.ToLowerInvariant())
+                    {
+                        case "?":
+                        case "h":
+                        case "help":
+                            cmdline.ShowHelp = true;
+                            return true;
+
+                        case "cultures":
+                            cmdline.GetNextArgumentOrError(cultures);
+                            return true;
+                        case "contentsfile":
+                            cmdline.GetNextArgumentOrError(ref contentsFile);
+                            return true;
+                        case "outputsfile":
+                            cmdline.GetNextArgumentOrError(ref outputsFile);
+                            return true;
+                        case "builtoutputsfile":
+                            cmdline.GetNextArgumentOrError(ref builtOutputsFile);
+                            return true;
+                        case "wixprojectfile":
+                            cmdline.GetNextArgumentOrError(ref wixProjectFile);
+                            return true;
+
+                        case "d":
+                        case "define":
+                            cmdline.GetNextArgumentOrError(defines);
+                            return true;
+
+                        case "i":
+                        case "includepath":
+                            cmdline.GetNextArgumentOrError(includePaths);
+                            return true;
+
+                        case "loc":
+                            cmdline.GetNextArgumentAsFilePathOrError(locFiles, "localization files");
+                            return true;
+
+                        case "o":
+                        case "out":
+                            cmdline.GetNextArgumentOrError(ref outputFile);
+                            return true;
+
+                        case "nologo":
+                            showLogo = false;
+                            return true;
+
+                        case "v":
+                        case "verbose":
+                            verbose = true;
+                            return true;
+
+                        case "version":
+                        case "-version":
+                            showVersion = true;
+                            return true;
+                    }
+
+                    return false;
+                }
+                else
+                {
+                    files.AddRange(cmdline.GetFiles(arg, "source code"));
+                    return true;
+                }
+            });
+
+            if (showVersion)
+            {
+                return new VersionCommand();
+            }
+
+            if (showLogo)
+            {
+                AppCommon.DisplayToolHeader();
+            }
+
+            if (cli.ShowHelp)
+            {
+                return new HelpCommand(command);
+            }
+
+            switch (command)
+            {
+                case Commands.Build:
+                    {
+                        var sourceFiles = GatherSourceFiles(files, outputFolder);
+                        var variables = GatherPreprocessorVariables(defines);
+                        var extensions = cli.ExtensionManager;
+                        return new BuildCommand(sourceFiles, variables, locFiles, outputFile, cultures, contentsFile, outputsFile, builtOutputsFile, wixProjectFile);
+                    }
+
+                case Commands.Compile:
+                    {
+                        var sourceFiles = GatherSourceFiles(files, outputFolder);
+                        var variables = GatherPreprocessorVariables(defines);
+                        return new CompileCommand(sourceFiles, variables);
+                    }
+            }
+
+            return null;
+        }
+
+        private static CommandLine Parse(string commandLineString, Func<CommandLine, string, bool> parseArgument)
+        {
+            var arguments = CommandLine.ParseArgumentsToArray(commandLineString).ToArray();
+
+            return CommandLine.Parse(arguments, null, parseArgument);
+        }
+
+        private static CommandLine Parse(string[] commandLineArguments, Func<CommandLine, string, bool> parseArgument)
+        {
+            return CommandLine.Parse(commandLineArguments, null, parseArgument);
+        }
+
+        private static CommandLine Parse(string[] commandLineArguments, Func<CommandLine, string, bool> parseCommand, Func<CommandLine, string, bool> parseArgument)
+        {
+            var cmdline = new CommandLine();
+
+            cmdline.FlattenArgumentsWithResponseFilesIntoOriginalArguments(commandLineArguments);
+
+            cmdline.QueueArgumentsAndLoadExtensions(cmdline.OriginalArguments);
+
+            cmdline.ProcessRemainingArguments(parseArgument, parseCommand);
+
+            return cmdline;
+        }
+
+        private static IEnumerable<SourceFile> GatherSourceFiles(IEnumerable<string> sourceFiles, string intermediateDirectory)
+        {
+            var files = new List<SourceFile>();
+
+            foreach (var item in sourceFiles)
+            {
+                var sourcePath = item;
+                var outputPath = Path.Combine(intermediateDirectory, Path.GetFileNameWithoutExtension(sourcePath) + ".wir");
+
+                files.Add(new SourceFile(sourcePath, outputPath));
+            }
+
+            return files;
+        }
+
+        private static IDictionary<string, string> GatherPreprocessorVariables(IEnumerable<string> defineConstants)
+        {
+            var variables = new Dictionary<string, string>();
+
+            foreach (var pair in defineConstants)
+            {
+                string[] value = pair.Split(new[] { '=' }, 2);
+
+                if (variables.ContainsKey(value[0]))
+                {
+                    Messaging.Instance.OnMessage(WixErrors.DuplicateVariableDefinition(value[0], (1 == value.Length) ? String.Empty : value[1], variables[value[0]]));
+                    continue;
+                }
+
+                variables.Add(value[0], (1 == value.Length) ? String.Empty : value[1]);
+            }
+
+            return variables;
+        }
+
+
+        /// <summary>
+        /// Get a set of files that possibly have a search pattern in the path (such as '*').
+        /// </summary>
+        /// <param name="searchPath">Search path to find files in.</param>
+        /// <param name="fileType">Type of file; typically "Source".</param>
+        /// <returns>An array of files matching the search path.</returns>
+        /// <remarks>
+        /// This method is written in this verbose way because it needs to support ".." in the path.
+        /// It needs the directory path isolated from the file name in order to use Directory.GetFiles
+        /// or DirectoryInfo.GetFiles.  The only way to get this directory path is manually since
+        /// Path.GetDirectoryName does not support ".." in the path.
+        /// </remarks>
+        /// <exception cref="WixFileNotFoundException">Throws WixFileNotFoundException if no file matching the pattern can be found.</exception>
+        public string[] GetFiles(string searchPath, string fileType)
+        {
+            if (null == searchPath)
+            {
+                throw new ArgumentNullException(nameof(searchPath));
+            }
+
+            // Convert alternate directory separators to the standard one.
+            string filePath = searchPath.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);
+            int lastSeparator = filePath.LastIndexOf(Path.DirectorySeparatorChar);
+            string[] files = null;
+
+            try
+            {
+                if (0 > lastSeparator)
+                {
+                    files = Directory.GetFiles(".", filePath);
+                }
+                else // found directory separator
+                {
+                    files = Directory.GetFiles(filePath.Substring(0, lastSeparator + 1), filePath.Substring(lastSeparator + 1));
+                }
+            }
+            catch (DirectoryNotFoundException)
+            {
+                // Don't let this function throw the DirectoryNotFoundException. This exception
+                // occurs for non-existant directories and invalid characters in the searchPattern.
+            }
+            catch (ArgumentException)
+            {
+                // Don't let this function throw the ArgumentException. This exception
+                // occurs in certain situations such as when passing a malformed UNC path.
+            }
+            catch (IOException)
+            {
+                throw new WixFileNotFoundException(searchPath, fileType);
+            }
+
+            if (null == files || 0 == files.Length)
+            {
+                throw new WixFileNotFoundException(searchPath, fileType);
+            }
+
+            return files;
+        }
+
+        /// <summary>
+        /// Validates that a valid switch (starts with "/" or "-"), and returns a bool indicating its validity
+        /// </summary>
+        /// <param name="args">The list of strings to check.</param>
+        /// <param name="index">The index (in args) of the commandline parameter to be validated.</param>
+        /// <returns>True if a valid switch exists there, false if not.</returns>
+        public bool IsSwitch(string arg)
+        {
+            return arg != null && ('/' == arg[0] || '-' == arg[0]);
+        }
+
+        /// <summary>
+        /// Validates that a valid switch (starts with "/" or "-"), and returns a bool indicating its validity
+        /// </summary>
+        /// <param name="args">The list of strings to check.</param>
+        /// <param name="index">The index (in args) of the commandline parameter to be validated.</param>
+        /// <returns>True if a valid switch exists there, false if not.</returns>
+        public bool IsSwitchAt(IEnumerable<string> args, int index)
+        {
+            var arg = args.ElementAtOrDefault(index);
+            return IsSwitch(arg);
+        }
+
+        public void GetNextArgumentOrError(ref string arg)
+        {
+            this.TryGetNextArgumentOrError(out arg);
+        }
+
+        public void GetNextArgumentOrError(IList<string> args)
+        {
+            if (this.TryGetNextArgumentOrError(out var arg))
+            {
+                args.Add(arg);
+            }
+        }
+
+        public void GetNextArgumentAsFilePathOrError(IList<string> args, string fileType)
+        {
+            if (this.TryGetNextArgumentOrError(out var arg))
+            {
+                foreach (var path in this.GetFiles(arg, fileType))
+                {
+                    args.Add(path);
+                }
+            }
+        }
+
+        public bool TryGetNextArgumentOrError(out string arg)
+        {
+            //if (this.RemainingArguments.TryDequeue(out arg) && !this.IsSwitch(arg))
+            if (TryDequeue(this.RemainingArguments, out arg) && !this.IsSwitch(arg))
+            {
+                return true;
+            }
+
+            this.ErrorArgument = arg ?? CommandLine.ExpectedArgument;
+
+            return false;
+        }
+
+        private static bool TryDequeue(Queue<string> q, out string arg)
+        {
+            if (q.Count> 0)
+            {
+                arg = q.Dequeue();
+                return true;
+            }
+
+            arg = null;
+            return false;
+        }
+
+        private void FlattenArgumentsWithResponseFilesIntoOriginalArguments(string[] commandLineArguments)
+        {
+            List<string> args = new List<string>();
+
+            foreach (var arg in commandLineArguments)
+            {
+                if ('@' == arg[0])
+                {
+                    var responseFileArguments = CommandLine.ParseResponseFile(arg.Substring(1));
+                    args.AddRange(responseFileArguments);
+                }
+                else
+                {
+                    args.Add(arg);
+                }
+            }
+
+            this.OriginalArguments = args.ToArray();
+        }
+
+        private void QueueArgumentsAndLoadExtensions(string[] args)
+        {
+            for (var i = 0; i < args.Length; ++i)
+            {
+                var arg = args[i];
+
+                if ("-ext" == arg || "/ext" == arg)
+                {
+                    if (!this.IsSwitchAt(args, ++i))
+                    {
+                        this.ExtensionManager.Load(args[i]);
+                    }
+                    else
+                    {
+                        this.ErrorArgument = arg;
+                        break;
+                    }
+                }
+                else
+                {
+                    this.RemainingArguments.Enqueue(arg);
+                }
+            }
+        }
+
+        private void ProcessRemainingArguments(Func<CommandLine, string, bool> parseArgument, Func<CommandLine, string, bool> parseCommand)
+        {
+            var extensions = this.ExtensionManager.Create<IExtensionCommandLine>();
+
+            while (!this.ShowHelp &&
+                   String.IsNullOrEmpty(this.ErrorArgument) &&
+                   TryDequeue(this.RemainingArguments, out var arg))
+            {
+                if (String.IsNullOrWhiteSpace(arg)) // skip blank arguments.
+                {
+                    continue;
+                }
+
+                if ('-' == arg[0] || '/' == arg[0])
+                {
+                    if (!parseArgument(this, arg) &&
+                        !this.TryParseCommandLineArgumentWithExtension(arg, extensions))
+                    {
+                        this.ErrorArgument = arg;
+                    }
+                }
+                else if (String.IsNullOrEmpty(this.ActiveCommand) && parseCommand != null) // First non-switch must be the command, if commands are supported.
+                {
+                    if (parseCommand(this, arg))
+                    {
+                        this.ActiveCommand = arg;
+                    }
+                    else
+                    {
+                        this.ErrorArgument = arg;
+                    }
+                }
+                else if (!this.TryParseCommandLineArgumentWithExtension(arg, extensions) &&
+                         !parseArgument(this, arg))
+                {
+                    this.ErrorArgument = arg;
+                }
+            }
+        }
+
+        private bool TryParseCommandLineArgumentWithExtension(string arg, IEnumerable<IExtensionCommandLine> extensions)
+        {
+            foreach (var extension in extensions)
+            {
+                //if (extension.ParseArgument(this, arg))
+                //{
+                //    return true;
+                //}
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Parses a response file.
+        /// </summary>
+        /// <param name="responseFile">The file to parse.</param>
+        /// <returns>The array of arguments.</returns>
+        private static List<string> ParseResponseFile(string responseFile)
+        {
+            string arguments;
+
+            using (StreamReader reader = new StreamReader(responseFile))
+            {
+                arguments = reader.ReadToEnd();
+            }
+
+            return CommandLine.ParseArgumentsToArray(arguments);
+        }
+
+        /// <summary>
+        /// Parses an argument string into an argument array based on whitespace and quoting.
+        /// </summary>
+        /// <param name="arguments">Argument string.</param>
+        /// <returns>Argument array.</returns>
+        private static List<string> ParseArgumentsToArray(string arguments)
+        {
+            // Scan and parse the arguments string, dividing up the arguments based on whitespace.
+            // Unescaped quotes cause whitespace to be ignored, while the quotes themselves are removed.
+            // Quotes may begin and end inside arguments; they don't necessarily just surround whole arguments.
+            // Escaped quotes and escaped backslashes also need to be unescaped by this process.
+
+            // Collects the final list of arguments to be returned.
+            var argsList = new List<string>();
+
+            // True if we are inside an unescaped quote, meaning whitespace should be ignored.
+            var insideQuote = false;
+
+            // Index of the start of the current argument substring; either the start of the argument
+            // or the start of a quoted or unquoted sequence within it.
+            var partStart = 0;
+
+            // The current argument string being built; when completed it will be added to the list.
+            var arg = new StringBuilder();
+
+            for (int i = 0; i <= arguments.Length; i++)
+            {
+                if (i == arguments.Length || (Char.IsWhiteSpace(arguments[i]) && !insideQuote))
+                {
+                    // Reached a whitespace separator or the end of the string.
+
+                    // Finish building the current argument.
+                    arg.Append(arguments.Substring(partStart, i - partStart));
+
+                    // Skip over the whitespace character.
+                    partStart = i + 1;
+
+                    // Add the argument to the list if it's not empty.
+                    if (arg.Length > 0)
+                    {
+                        argsList.Add(CommandLine.ExpandEnvVars(arg.ToString()));
+                        arg.Length = 0;
+                    }
+                }
+                else if (i > partStart && arguments[i - 1] == '\\')
+                {
+                    // Check the character following an unprocessed backslash.
+                    // Unescape quotes, and backslashes followed by a quote.
+                    if (arguments[i] == '"' || (arguments[i] == '\\' && arguments.Length > i + 1 && arguments[i + 1] == '"'))
+                    {
+                        // Unescape the quote or backslash by skipping the preceeding backslash.
+                        arg.Append(arguments.Substring(partStart, i - 1 - partStart));
+                        arg.Append(arguments[i]);
+                        partStart = i + 1;
+                    }
+                }
+                else if (arguments[i] == '"')
+                {
+                    // Add the quoted or unquoted section to the argument string.
+                    arg.Append(arguments.Substring(partStart, i - partStart));
+
+                    // And skip over the quote character.
+                    partStart = i + 1;
+
+                    insideQuote = !insideQuote;
+                }
+            }
+
+            return argsList;
+        }
+
+        /// <summary>
+        /// Expand enxironment variables contained in the passed string
+        /// </summary>
+        /// <param name="arguments"></param>
+        /// <returns></returns>
+        private static string ExpandEnvVars(string arguments)
+        {
+            var id = Environment.GetEnvironmentVariables();
+
+            var regex = new Regex("(?<=\\%)(?:[\\w\\.]+)(?=\\%)");
+            MatchCollection matches = regex.Matches(arguments);
+
+            string value = String.Empty;
+            for (int i = 0; i <= (matches.Count - 1); i++)
+            {
+                try
+                {
+                    var key = matches[i].Value;
+                    regex = new Regex(String.Concat("(?i)(?:\\%)(?:", key, ")(?:\\%)"));
+                    value = id[key].ToString();
+                    arguments = regex.Replace(arguments, value);
+                }
+                catch (NullReferenceException)
+                {
+                    // Collapse unresolved environment variables.
+                    arguments = regex.Replace(arguments, value);
+                }
+            }
+
+            return arguments;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/CommandLine/CommandLineHelper.cs b/src/WixToolset.Core/CommandLine/CommandLineHelper.cs
new file mode 100644
index 00000000..86724603
--- /dev/null
+++ b/src/WixToolset.Core/CommandLine/CommandLineHelper.cs
@@ -0,0 +1,255 @@
+// 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
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Text;
+    using WixToolset.Data;
+    using WixToolset.Extensibility;
+
+    /// <summary>
+    /// Common utilities for Wix command-line processing.
+    /// </summary>
+    public static class CommandLineHelper
+    {
+        /// <summary>
+        /// Get a set of files that possibly have a search pattern in the path (such as '*').
+        /// </summary>
+        /// <param name="searchPath">Search path to find files in.</param>
+        /// <param name="fileType">Type of file; typically "Source".</param>
+        /// <returns>An array of files matching the search path.</returns>
+        /// <remarks>
+        /// This method is written in this verbose way because it needs to support ".." in the path.
+        /// It needs the directory path isolated from the file name in order to use Directory.GetFiles
+        /// or DirectoryInfo.GetFiles.  The only way to get this directory path is manually since
+        /// Path.GetDirectoryName does not support ".." in the path.
+        /// </remarks>
+        /// <exception cref="WixFileNotFoundException">Throws WixFileNotFoundException if no file matching the pattern can be found.</exception>
+        public static string[] GetFiles(string searchPath, string fileType)
+        {
+            if (null == searchPath)
+            {
+                throw new ArgumentNullException("searchPath");
+            }
+
+            // convert alternate directory separators to the standard one
+            string filePath = searchPath.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);
+            int lastSeparator = filePath.LastIndexOf(Path.DirectorySeparatorChar);
+            string[] files = null;
+
+            try
+            {
+                if (0 > lastSeparator)
+                {
+                    files = Directory.GetFiles(".", filePath);
+                }
+                else // found directory separator
+                {
+                    files = Directory.GetFiles(filePath.Substring(0, lastSeparator + 1), filePath.Substring(lastSeparator + 1));
+                }
+            }
+            catch (DirectoryNotFoundException)
+            {
+                // don't let this function throw the DirectoryNotFoundException. (this exception
+                // occurs for non-existant directories and invalid characters in the searchPattern)
+            }
+            catch (ArgumentException)
+            {
+                // don't let this function throw the ArgumentException. (this exception
+                // occurs in certain situations such as when passing a malformed UNC path)
+            }
+            catch (IOException)
+            {
+                throw new WixFileNotFoundException(searchPath, fileType);
+            }
+
+            // file could not be found or path is invalid in some way
+            if (null == files || 0 == files.Length)
+            {
+                throw new WixFileNotFoundException(searchPath, fileType);
+            }
+
+            return files;
+        }
+
+        /// <summary>
+        /// Validates that a valid string parameter (without "/" or "-"), and returns a bool indicating its validity
+        /// </summary>
+        /// <param name="args">The list of strings to check.</param>
+        /// <param name="index">The index (in args) of the commandline parameter to be validated.</param>
+        /// <returns>True if a valid string parameter exists there, false if not.</returns>
+        public static bool IsValidArg(string[] args, int index)
+        {
+            if (args.Length <= index || String.IsNullOrEmpty(args[index]) || '/' == args[index][0] || '-' == args[index][0])
+            {
+                return false;
+            }
+            else
+            {
+                return true;
+            }
+        }
+
+        /// <summary>
+        /// Validates that a commandline parameter is a valid file or directory name, and throws appropriate warnings/errors if not
+        /// </summary>
+        /// <param name="path">The path to test.</param>
+        /// <returns>The string if it is valid, null if it is invalid.</returns>
+        public static string VerifyPath(string path)
+        {
+            return VerifyPath(path, false);
+        }
+
+        /// <summary>
+        /// Validates that a commandline parameter is a valid file or directory name, and throws appropriate warnings/errors if not
+        /// </summary>
+        /// <param name="path">The path to test.</param>
+        /// <param name="allowPrefix">Indicates if a colon-delimited prefix is allowed.</param>
+        /// <returns>The full path if it is valid, null if it is invalid.</returns>
+        public static string VerifyPath(string path, bool allowPrefix)
+        {
+            string fullPath;
+
+            if (0 <= path.IndexOf('\"'))
+            {
+                Messaging.Instance.OnMessage(WixErrors.PathCannotContainQuote(path));
+                return null;
+            }
+
+            try
+            {
+                string prefix = null;
+                if (allowPrefix)
+                {
+                    int prefixLength = path.IndexOf('=') + 1;
+                    if (0 != prefixLength)
+                    {
+                      prefix = path.Substring(0, prefixLength);
+                      path = path.Substring(prefixLength);
+                    }
+                }
+
+                if (String.IsNullOrEmpty(prefix))
+                {
+                    fullPath = Path.GetFullPath(path);
+                }
+                else
+                {
+                    fullPath = String.Concat(prefix, Path.GetFullPath(path));
+                }
+            }
+            catch (Exception e)
+            {
+                Messaging.Instance.OnMessage(WixErrors.InvalidCommandLineFileName(path, e.Message));
+                return null;
+            }
+
+            return fullPath;
+        }
+
+        /// <summary>
+        /// Validates that a string is a valid bind path, and throws appropriate warnings/errors if not
+        /// </summary>
+        /// <param name="commandlineSwitch">The commandline switch we're parsing (for error display purposes).</param>
+        /// <param name="args">The list of strings to check.</param>
+        /// <param name="index">The index (in args) of the commandline parameter to be parsed.</param>
+        /// <returns>The bind path if it is valid, null if it is invalid.</returns>
+        public static BindPath GetBindPath(string commandlineSwitch, string[] args, int index)
+        {
+            commandlineSwitch = String.Concat("-", commandlineSwitch);
+
+            if (!IsValidArg(args, index))
+            {
+                Messaging.Instance.OnMessage(WixErrors.DirectoryPathRequired(commandlineSwitch));
+                return null;
+            }
+
+            BindPath bindPath = BindPath.Parse(args[index]);
+
+            if (File.Exists(bindPath.Path))
+            {
+                Messaging.Instance.OnMessage(WixErrors.ExpectedDirectoryGotFile(commandlineSwitch, bindPath.Path));
+                return null;
+            }
+
+            bindPath.Path = VerifyPath(bindPath.Path, true);
+            return String.IsNullOrEmpty(bindPath.Path) ? null : bindPath;
+        }
+
+        /// <summary>
+        /// Validates that a commandline parameter is a valid file or directory name, and throws appropriate warnings/errors if not
+        /// </summary>
+        /// <param name="commandlineSwitch">The commandline switch we're parsing (for error display purposes).</param>
+        /// <param name="messageHandler">The messagehandler to report warnings/errors to.</param>
+        /// <param name="args">The list of strings to check.</param>
+        /// <param name="index">The index (in args) of the commandline parameter to be parsed.</param>
+        /// <returns>The string if it is valid, null if it is invalid.</returns>
+        public static string GetFileOrDirectory(string commandlineSwitch, string[] args, int index)
+        {
+            commandlineSwitch = String.Concat("-", commandlineSwitch);
+
+            if (!IsValidArg(args, index))
+            {
+                Messaging.Instance.OnMessage(WixErrors.FileOrDirectoryPathRequired(commandlineSwitch));
+                return null;
+            }
+
+            return VerifyPath(args[index]);
+        }
+
+        /// <summary>
+        /// Validates that a string is a valid directory name, and throws appropriate warnings/errors if not
+        /// </summary>
+        /// <param name="commandlineSwitch">The commandline switch we're parsing (for error display purposes).</param>
+        /// <param name="args">The list of strings to check.</param>
+        /// <param name="index">The index (in args) of the commandline parameter to be parsed.</param>
+        /// <param name="allowPrefix">Indicates if a colon-delimited prefix is allowed.</param>
+        /// <returns>The string if it is valid, null if it is invalid.</returns>
+        public static string GetDirectory(string commandlineSwitch, string[] args, int index, bool allowPrefix = false)
+        {
+            commandlineSwitch = String.Concat("-", commandlineSwitch);
+
+            if (!IsValidArg(args, index))
+            {
+                Messaging.Instance.OnMessage(WixErrors.DirectoryPathRequired(commandlineSwitch));
+                return null;
+            }
+
+            if (File.Exists(args[index]))
+            {
+                Messaging.Instance.OnMessage(WixErrors.ExpectedDirectoryGotFile(commandlineSwitch, args[index]));
+                return null;
+            }
+
+            return VerifyPath(args[index], allowPrefix);
+        }
+
+        /// <summary>
+        /// Validates that a string is a valid filename, and throws appropriate warnings/errors if not
+        /// </summary>
+        /// <param name="commandlineSwitch">The commandline switch we're parsing (for error display purposes).</param>
+        /// <param name="args">The list of strings to check.</param>
+        /// <param name="index">The index (in args) of the commandline parameter to be parsed.</param>
+        /// <returns>The string if it is valid, null if it is invalid.</returns>
+        public static string GetFile(string commandlineSwitch, string[] args, int index)
+        {
+            commandlineSwitch = String.Concat("-", commandlineSwitch);
+
+            if (!IsValidArg(args, index))
+            {
+                Messaging.Instance.OnMessage(WixErrors.FilePathRequired(commandlineSwitch));
+                return null;
+            }
+
+            if (Directory.Exists(args[index]))
+            {
+                Messaging.Instance.OnMessage(WixErrors.ExpectedFileGotDirectory(commandlineSwitch, args[index]));
+                return null;
+            }
+
+            return VerifyPath(args[index]);
+        }
+    }
+}
diff --git a/src/WixToolset.Core/CommandLine/CommandLineOption.cs b/src/WixToolset.Core/CommandLine/CommandLineOption.cs
new file mode 100644
index 00000000..85a654bf
--- /dev/null
+++ b/src/WixToolset.Core/CommandLine/CommandLineOption.cs
@@ -0,0 +1,27 @@
+// 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
+{
+    /// <summary>
+    /// A command line option.
+    /// </summary>
+    public struct CommandLineOption
+    {
+        public string Option;
+        public string Description;
+        public int AdditionalArguments;
+
+        /// <summary>
+        /// Instantiates a new BuilderCommandLineOption.
+        /// </summary>
+        /// <param name="option">The option name.</param>
+        /// <param name="description">The description of the option.</param>
+        /// <param name="additionalArguments">Count of additional arguments to require after this switch.</param>
+        public CommandLineOption(string option, string description, int additionalArguments)
+        {
+            this.Option = option;
+            this.Description = description;
+            this.AdditionalArguments = additionalArguments;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/CommandLine/CommandLineResponseFile.cs b/src/WixToolset.Core/CommandLine/CommandLineResponseFile.cs
new file mode 100644
index 00000000..f27296b7
--- /dev/null
+++ b/src/WixToolset.Core/CommandLine/CommandLineResponseFile.cs
@@ -0,0 +1,137 @@
+// 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
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Text;
+    using System.Text.RegularExpressions;
+
+    /// <summary>
+    /// Common utilities for Wix command-line processing.
+    /// </summary>
+    public static class CommandLineResponseFile
+    {
+        /// <summary>
+        /// Parses a response file.
+        /// </summary>
+        /// <param name="responseFile">The file to parse.</param>
+        /// <returns>The array of arguments.</returns>
+        public static string[] Parse(string responseFile)
+        {
+            string arguments;
+
+            using (StreamReader reader = new StreamReader(responseFile))
+            {
+                arguments = reader.ReadToEnd();
+            }
+
+            return CommandLineResponseFile.ParseArgumentsToArray(arguments);
+        }
+
+        /// <summary>
+        /// Parses an argument string into an argument array based on whitespace and quoting.
+        /// </summary>
+        /// <param name="arguments">Argument string.</param>
+        /// <returns>Argument array.</returns>
+        public static string[] ParseArgumentsToArray(string arguments)
+        {
+            // Scan and parse the arguments string, dividing up the arguments based on whitespace.
+            // Unescaped quotes cause whitespace to be ignored, while the quotes themselves are removed.
+            // Quotes may begin and end inside arguments; they don't necessarily just surround whole arguments.
+            // Escaped quotes and escaped backslashes also need to be unescaped by this process.
+
+            // Collects the final list of arguments to be returned.
+            List<string> argsList = new List<string>();
+
+            // True if we are inside an unescaped quote, meaning whitespace should be ignored.
+            bool insideQuote = false;
+
+            // Index of the start of the current argument substring; either the start of the argument
+            // or the start of a quoted or unquoted sequence within it.
+            int partStart = 0;
+
+            // The current argument string being built; when completed it will be added to the list.
+            StringBuilder arg = new StringBuilder();
+
+            for (int i = 0; i <= arguments.Length; i++)
+            {
+                if (i == arguments.Length || (Char.IsWhiteSpace(arguments[i]) && !insideQuote))
+                {
+                    // Reached a whitespace separator or the end of the string.
+
+                    // Finish building the current argument.
+                    arg.Append(arguments.Substring(partStart, i - partStart));
+
+                    // Skip over the whitespace character.
+                    partStart = i + 1;
+
+                    // Add the argument to the list if it's not empty.
+                    if (arg.Length > 0)
+                    {
+                        argsList.Add(CommandLineResponseFile.ExpandEnvVars(arg.ToString()));
+                        arg.Length = 0;
+                    }
+                }
+                else if (i > partStart && arguments[i - 1] == '\\')
+                {
+                    // Check the character following an unprocessed backslash.
+                    // Unescape quotes, and backslashes followed by a quote.
+                    if (arguments[i] == '"' || (arguments[i] == '\\' && arguments.Length > i + 1 && arguments[i + 1] == '"'))
+                    {
+                        // Unescape the quote or backslash by skipping the preceeding backslash.
+                        arg.Append(arguments.Substring(partStart, i - 1 - partStart));
+                        arg.Append(arguments[i]);
+                        partStart = i + 1;
+                    }
+                }
+                else if (arguments[i] == '"')
+                {
+                    // Add the quoted or unquoted section to the argument string.
+                    arg.Append(arguments.Substring(partStart, i - partStart));
+
+                    // And skip over the quote character.
+                    partStart = i + 1;
+
+                    insideQuote = !insideQuote;
+                }
+            }
+
+            return argsList.ToArray();
+        }
+
+        /// <summary>
+        /// Expand enxironment variables contained in the passed string
+        /// </summary>
+        /// <param name="arguments"></param>
+        /// <returns></returns>
+        static private string ExpandEnvVars(string arguments)
+        {
+            IDictionary id = Environment.GetEnvironmentVariables();
+
+            Regex regex = new Regex("(?<=\\%)(?:[\\w\\.]+)(?=\\%)");
+            MatchCollection matches = regex.Matches(arguments);
+
+            string value = String.Empty;
+            for (int i = 0; i <= (matches.Count - 1); i++)
+            {
+                try
+                {
+                    string key = matches[i].Value;
+                    regex = new Regex(String.Concat("(?i)(?:\\%)(?:" , key , ")(?:\\%)"));
+                    value = id[key].ToString();
+                    arguments = regex.Replace(arguments, value);
+                }
+                catch (NullReferenceException)
+                {
+                    // Collapse unresolved environment variables.
+                    arguments = regex.Replace(arguments, value);
+                }
+            }
+
+            return arguments;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/CommandLine/CompileCommand.cs b/src/WixToolset.Core/CommandLine/CompileCommand.cs
new file mode 100644
index 00000000..17847b57
--- /dev/null
+++ b/src/WixToolset.Core/CommandLine/CompileCommand.cs
@@ -0,0 +1,39 @@
+// 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.Core
+{
+    using System;
+    using System.Collections.Generic;
+    using WixToolset.Data;
+
+    internal class CompileCommand : ICommand
+    {
+        public CompileCommand(IEnumerable<SourceFile> sources, IDictionary<string, string> preprocessorVariables)
+        {
+            this.PreprocessorVariables = preprocessorVariables;
+            this.SourceFiles = sources;
+        }
+
+        private IEnumerable<SourceFile> SourceFiles { get; }
+
+        private IDictionary<string, string> PreprocessorVariables { get; }
+
+        public int Execute()
+        {
+            var preprocessor = new Preprocessor();
+
+            var compiler = new Compiler();
+
+            foreach (var sourceFile in this.SourceFiles)
+            {
+                var document = preprocessor.Process(sourceFile.SourcePath, this.PreprocessorVariables);
+
+                var intermediate = compiler.Compile(document);
+
+                intermediate.Save(sourceFile.OutputPath);
+            }
+
+            return 0;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/CommandLine/HelpCommand.cs b/src/WixToolset.Core/CommandLine/HelpCommand.cs
new file mode 100644
index 00000000..1c101781
--- /dev/null
+++ b/src/WixToolset.Core/CommandLine/HelpCommand.cs
@@ -0,0 +1,30 @@
+// 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.Core
+{
+    using System;
+
+    internal class HelpCommand : ICommand
+    {
+        public HelpCommand(Commands command)
+        {
+            this.Command = command;
+        }
+
+        public Commands Command { get; }
+
+        public int Execute()
+        {
+            if (this.Command == Commands.Unknown)
+            {
+                Console.WriteLine();
+            }
+            else
+            {
+                Console.WriteLine();
+            }
+
+            return -1;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/CommandLine/ICommand.cs b/src/WixToolset.Core/CommandLine/ICommand.cs
new file mode 100644
index 00000000..41abbbdc
--- /dev/null
+++ b/src/WixToolset.Core/CommandLine/ICommand.cs
@@ -0,0 +1,9 @@
+// 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.Core
+{
+    public interface ICommand
+    {
+        int Execute();
+    }
+}
diff --git a/src/WixToolset.Core/CommandLine/VersionCommand.cs b/src/WixToolset.Core/CommandLine/VersionCommand.cs
new file mode 100644
index 00000000..a1980a2b
--- /dev/null
+++ b/src/WixToolset.Core/CommandLine/VersionCommand.cs
@@ -0,0 +1,17 @@
+// 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.
+
+using System;
+
+namespace WixToolset.Core
+{
+    internal class VersionCommand : ICommand
+    {
+        public int Execute()
+        {
+            Console.WriteLine("wix version {0}", ThisAssembly.AssemblyInformationalVersion);
+            Console.WriteLine();
+
+            return 0;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Common.cs b/src/WixToolset.Core/Common.cs
new file mode 100644
index 00000000..0404de5e
--- /dev/null
+++ b/src/WixToolset.Core/Common.cs
@@ -0,0 +1,665 @@
+// 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
+{
+    using System;
+    using System.Diagnostics;
+    using System.Globalization;
+    using System.IO;
+    using System.Linq;
+    using System.Security.Cryptography;
+    using System.Text;
+    using System.Text.RegularExpressions;
+    using System.Xml;
+    using System.Xml.Linq;
+    using WixToolset.Data;
+
+    /// <summary>
+    /// Common Wix utility methods and types.
+    /// </summary>
+    internal static class Common
+    {
+        //-------------------------------------------------------------------------------------------------
+        // Layout of an Access Mask (from http://technet.microsoft.com/en-us/library/cc783530(WS.10).aspx)
+        //
+        //  -------------------------------------------------------------------------------------------------
+        //  |31|30|29|28|27|26|25|24|23|22|21|20|19|18|17|16|15|14|13|12|11|10|09|08|07|06|05|04|03|02|01|00|
+        //  -------------------------------------------------------------------------------------------------
+        //  |GR|GW|GE|GA| Reserved  |AS|StandardAccessRights|        Object-Specific Access Rights          |
+        //
+        //  Key
+        //  GR = Generic Read
+        //  GW = Generic Write
+        //  GE = Generic Execute
+        //  GA = Generic All
+        //  AS = Right to access SACL
+        //
+        // TODO: what is the expected decompile behavior if a bit is found that is not explicitly enumerated
+        //
+        //-------------------------------------------------------------------------------------------------
+        // Generic Access Rights (per WinNT.h)
+        // ---------------------
+        // GENERIC_ALL                      (0x10000000L)
+        // GENERIC_EXECUTE                  (0x20000000L)
+        // GENERIC_WRITE                    (0x40000000L)
+        // GENERIC_READ                     (0x80000000L)
+        internal static readonly string[] GenericPermissions = { "GenericAll", "GenericExecute", "GenericWrite", "GenericRead" };
+
+        // Standard Access Rights (per WinNT.h)
+        // ----------------------
+        // DELETE                           (0x00010000L)
+        // READ_CONTROL                     (0x00020000L)
+        // WRITE_DAC                        (0x00040000L)
+        // WRITE_OWNER                      (0x00080000L)
+        // SYNCHRONIZE                      (0x00100000L)
+        internal static readonly string[] StandardPermissions = { "Delete", "ReadPermission", "ChangePermission", "TakeOwnership", "Synchronize" };
+
+        // Object-Specific Access Rights
+        // =============================
+        // Directory Access Rights (per WinNT.h)
+        // -----------------------
+        // FILE_LIST_DIRECTORY       ( 0x0001 )
+        // FILE_ADD_FILE             ( 0x0002 )
+        // FILE_ADD_SUBDIRECTORY     ( 0x0004 )
+        // FILE_READ_EA              ( 0x0008 )
+        // FILE_WRITE_EA             ( 0x0010 )
+        // FILE_TRAVERSE             ( 0x0020 )
+        // FILE_DELETE_CHILD         ( 0x0040 )
+        // FILE_READ_ATTRIBUTES      ( 0x0080 )
+        // FILE_WRITE_ATTRIBUTES     ( 0x0100 )
+        internal static readonly string[] FolderPermissions = { "Read", "CreateFile", "CreateChild", "ReadExtendedAttributes", "WriteExtendedAttributes", "Traverse", "DeleteChild", "ReadAttributes", "WriteAttributes" };
+
+        // Registry Access Rights (per TODO)
+        // ----------------------
+        internal static readonly string[] RegistryPermissions = { "Read", "Write", "CreateSubkeys", "EnumerateSubkeys", "Notify", "CreateLink" };
+
+        // File Access Rights (per WinNT.h)
+        // ------------------
+        // FILE_READ_DATA            ( 0x0001 )
+        // FILE_WRITE_DATA           ( 0x0002 )
+        // FILE_APPEND_DATA          ( 0x0004 )
+        // FILE_READ_EA              ( 0x0008 )
+        // FILE_WRITE_EA             ( 0x0010 )
+        // FILE_EXECUTE              ( 0x0020 )
+        // via mask FILE_ALL_ACCESS  ( 0x0040 )
+        // FILE_READ_ATTRIBUTES      ( 0x0080 )
+        // FILE_WRITE_ATTRIBUTES     ( 0x0100 )
+        //
+        // STANDARD_RIGHTS_REQUIRED  (0x000F0000L)
+        // FILE_ALL_ACCESS           (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0x1FF)
+        internal static readonly string[] FilePermissions = { "Read", "Write", "Append", "ReadExtendedAttributes", "WriteExtendedAttributes", "Execute", "FileAllRights", "ReadAttributes", "WriteAttributes" };
+
+        internal static readonly string[] ReservedFileNames = { "CON", "PRN", "AUX", "NUL", "COM1", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7", "COM8", "COM9", "LPT1", "LPT2", "LPT3", "LPT4", "LPT5", "LPT6", "LPT7", "LPT8", "LPT9" };
+
+        internal static readonly Regex WixVariableRegex = new Regex(@"(\!|\$)\((?<namespace>loc|wix|bind|bindpath)\.(?<fullname>(?<name>[_A-Za-z][0-9A-Za-z_]+)(\.(?<scope>[_A-Za-z][0-9A-Za-z_\.]*))?)(\=(?<value>.+?))?\)", RegexOptions.Compiled | RegexOptions.Singleline | RegexOptions.ExplicitCapture);
+
+        internal const char CustomRowFieldSeparator = '\x85';
+
+        private static readonly Regex PropertySearch = new Regex(@"\[[#$!]?[a-zA-Z_][a-zA-Z0-9_\.]*]", RegexOptions.Singleline);
+        private static readonly Regex AddPrefix = new Regex(@"^[^a-zA-Z_]", RegexOptions.Compiled);
+        private static readonly Regex LegalIdentifierCharacters = new Regex(@"^[_A-Za-z][0-9A-Za-z_\.]*$", RegexOptions.Compiled);
+        private static readonly Regex IllegalIdentifierCharacters = new Regex(@"[^A-Za-z0-9_\.]|\.{2,}", RegexOptions.Compiled); // non 'words' and assorted valid characters
+
+        private const string LegalShortFilenameCharacters = @"[^\\\?|><:/\*""\+,;=\[\]\. ]"; // illegal: \ ? | > < : / * " + , ; = [ ] . (space)
+        private static readonly Regex LegalShortFilename = new Regex(String.Concat("^", LegalShortFilenameCharacters, @"{1,8}(\.", LegalShortFilenameCharacters, "{0,3})?$"), RegexOptions.Compiled);
+
+        private const string LegalWildcardShortFilenameCharacters = @"[^\\|><:/""\+,;=\[\]\. ]"; // illegal: \ | > < : / " + , ; = [ ] . (space)
+        private static readonly Regex LegalWildcardShortFilename = new Regex(String.Concat("^", LegalWildcardShortFilenameCharacters, @"{1,16}(\.", LegalWildcardShortFilenameCharacters, "{0,6})?$"));
+
+        /// <summary>
+        /// Cleans up the temp files.
+        /// </summary>
+        /// <param name="path">The temporary directory to delete.</param>
+        /// <param name="messageHandler">The message handler.</param>
+        /// <returns>True if all files were deleted, false otherwise.</returns>
+        internal static bool DeleteTempFiles(string path, IMessageHandler messageHandler)
+        {
+            // try three times and give up with a warning if the temp files aren't gone by then
+            int retryLimit = 3;
+            bool removedReadOnly = false;
+
+            for (int i = 0; i < retryLimit; i++)
+            {
+                try
+                {
+                    Directory.Delete(path, true);   // toast the whole temp directory
+                    break; // no exception means we got success the first time
+                }
+                catch (UnauthorizedAccessException)
+                {
+                    if (!removedReadOnly) // should only need to unmark readonly once - there's no point in doing it again and again
+                    {
+                        removedReadOnly = true;
+                        RecursiveFileAttributes(path, FileAttributes.ReadOnly, false, messageHandler); // toasting will fail if any files are read-only. Try changing them to not be.
+                    }
+                    else
+                    {
+                        messageHandler.OnMessage(WixWarnings.AccessDeniedForDeletion(null, path));
+                        return false;
+                    }
+                }
+                catch (DirectoryNotFoundException)
+                {
+                    // if the path doesn't exist, then there is nothing for us to worry about
+                    break;
+                }
+                catch (IOException) // directory in use
+                {
+                    if (i == (retryLimit - 1)) // last try failed still, give up
+                    {
+                        messageHandler.OnMessage(WixWarnings.DirectoryInUse(null, path));
+                        return false;
+                    }
+
+                    System.Threading.Thread.Sleep(300);  // sleep a bit before trying again
+                }
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Gets a valid code page from the given web name or integer value.
+        /// </summary>
+        /// <param name="value">A code page web name or integer value as a string.</param>
+        /// <param name="allowNoChange">Whether to allow -1 which does not change the database code pages. This may be the case with wxl files.</param>
+        /// <param name="onlyAnsi">Whether to allow Unicode (UCS) or UTF code pages.</param>
+        /// <param name="sourceLineNumbers">Source line information for the current authoring.</param>
+        /// <returns>A valid code page number.</returns>
+        /// <exception cref="ArgumentOutOfRangeException">The value is an integer less than 0 or greater than 65535.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="value"/> is null.</exception>
+        /// <exception cref="NotSupportedException">The value doesn't not represent a valid code page name or integer value.</exception>
+        /// <exception cref="WixException">The code page is invalid for summary information.</exception>
+        internal static int GetValidCodePage(string value, bool allowNoChange = false, bool onlyAnsi = false, SourceLineNumber sourceLineNumbers = null)
+        {
+            int codePage;
+            Encoding encoding;
+
+            try
+            {
+                // check if a integer as a string was passed
+                if (Int32.TryParse(value, out codePage))
+                {
+                    if (0 == codePage)
+                    {
+                        // 0 represents a neutral database
+                        return 0;
+                    }
+                    else if (allowNoChange && -1 == codePage)
+                    {
+                        // -1 means no change to the database code page
+                        return -1;
+                    }
+
+                    encoding = Encoding.GetEncoding(codePage);
+                }
+                else
+                {
+                    encoding = Encoding.GetEncoding(value);
+                }
+
+                // Windows Installer parses some code page references
+                // as unsigned shorts which fail to open the database.
+                if (onlyAnsi)
+                {
+                    codePage = encoding.CodePage;
+                    if (0 > codePage || Int16.MaxValue < codePage)
+                    {
+                        throw new WixException(WixErrors.InvalidSummaryInfoCodePage(sourceLineNumbers, codePage));
+                    }
+                }
+
+                return encoding.CodePage;
+            }
+            catch (ArgumentException ex)
+            {
+                // rethrow as NotSupportedException since either can be thrown
+                // if the system does not support the specified code page
+                throw new NotSupportedException(ex.Message, ex);
+            }
+        }
+
+        /// <summary>
+        /// Verifies if a filename is a valid short filename.
+        /// </summary>
+        /// <param name="filename">Filename to verify.</param>
+        /// <param name="allowWildcards">true if wildcards are allowed in the filename.</param>
+        /// <returns>True if the filename is a valid short filename</returns>
+        internal static bool IsValidShortFilename(string filename, bool allowWildcards)
+        {
+            if (String.IsNullOrEmpty(filename))
+            {
+                return false;
+            }
+
+            if (allowWildcards)
+            {
+                if (Common.LegalWildcardShortFilename.IsMatch(filename))
+                {
+                    bool foundPeriod = false;
+                    int beforePeriod = 0;
+                    int afterPeriod = 0;
+
+                    // count the number of characters before and after the period
+                    // '*' is not counted because it may represent zero characters
+                    foreach (char character in filename)
+                    {
+                        if ('.' == character)
+                        {
+                            foundPeriod = true;
+                        }
+                        else if ('*' != character)
+                        {
+                            if (foundPeriod)
+                            {
+                                afterPeriod++;
+                            }
+                            else
+                            {
+                                beforePeriod++;
+                            }
+                        }
+                    }
+
+                    if (8 >= beforePeriod && 3 >= afterPeriod)
+                    {
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+            else
+            {
+                return Common.LegalShortFilename.IsMatch(filename);
+            }
+        }
+
+        /// <summary>
+        /// Verifies if an identifier is a valid binder variable name.
+        /// </summary>
+        /// <param name="name">Binder variable name to verify.</param>
+        /// <returns>True if the identifier is a valid binder variable name.</returns>
+        public static bool IsValidBinderVariable(string name)
+        {
+            if (String.IsNullOrEmpty(name))
+            {
+                return false;
+            }
+
+            Match match = Common.WixVariableRegex.Match(name);
+
+            return (match.Success && ("bind" == match.Groups["namespace"].Value || "wix" == match.Groups["namespace"].Value) && 0 == match.Index && name.Length == match.Length);
+        }
+
+        /// <summary>
+        /// Verifies if a string contains a valid binder variable name.
+        /// </summary>
+        /// <param name="name">String to verify.</param>
+        /// <returns>True if the string contains a valid binder variable name.</returns>
+        public static bool ContainsValidBinderVariable(string name)
+        {
+            if (String.IsNullOrEmpty(name))
+            {
+                return false;
+            }
+
+            Match match = Common.WixVariableRegex.Match(name);
+
+            return match.Success && ("bind" == match.Groups["namespace"].Value || "wix" == match.Groups["namespace"].Value);
+        }
+
+        /// <summary>
+        /// Get the value of an attribute with type YesNoType.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source information for the value.</param>
+        /// <param name="elementName">Name of the element for this attribute, used for a possible exception.</param>
+        /// <param name="attributeName">Name of the attribute.</param>
+        /// <param name="value">Value to process.</param>
+        /// <returns>Returns true for a value of 'yes' and false for a value of 'no'.</returns>
+        /// <exception cref="WixException">Thrown when the attribute's value is not 'yes' or 'no'.</exception>
+        internal static bool IsYes(SourceLineNumber sourceLineNumbers, string elementName, string attributeName, string value)
+        {
+            switch (value)
+            {
+                case "no":
+                case "false":
+                    return false;
+                case "yes":
+                case "true":
+                    return true;
+                default:
+                    throw new WixException(WixErrors.IllegalAttributeValue(sourceLineNumbers, elementName, attributeName, value, "no", "yes"));
+            }
+        }
+
+        /// <summary>
+        /// Verifies the given string is a valid module or bundle version.
+        /// </summary>
+        /// <param name="version">The version to verify.</param>
+        /// <returns>True if version is a valid module or bundle version.</returns>
+        public static bool IsValidModuleOrBundleVersion(string version)
+        {
+            if (!Common.IsValidBinderVariable(version))
+            {
+                Version ver = null;
+                
+                try
+                {
+                    ver = new Version(version);
+                }
+                catch (ArgumentException)
+                {
+                    return false;
+                }
+
+                if (65535 < ver.Major || 65535 < ver.Minor || 65535 < ver.Build || 65535 < ver.Revision)
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Generate a new Windows Installer-friendly guid.
+        /// </summary>
+        /// <returns>A new guid.</returns>
+        internal static string GenerateGuid()
+        {
+            return Guid.NewGuid().ToString("B").ToUpper(CultureInfo.InvariantCulture);
+        }
+
+        /// <summary>
+        /// Generate an identifier by hashing data from the row.
+        /// </summary>
+        /// <param name="prefix">Three letter or less prefix for generated row identifier.</param>
+        /// <param name="args">Information to hash.</param>
+        /// <returns>The generated identifier.</returns>
+        public static string GenerateIdentifier(string prefix, params string[] args)
+        {
+            string stringData = String.Join("|", args);
+            byte[] data = Encoding.UTF8.GetBytes(stringData);
+
+            // hash the data
+            byte[] hash;
+            using (SHA1 sha1 = new SHA1CryptoServiceProvider())
+            {
+                hash = sha1.ComputeHash(data);
+            }
+
+            // Build up the identifier.
+            StringBuilder identifier = new StringBuilder(35, 35);
+            identifier.Append(prefix);
+            identifier.Append(Convert.ToBase64String(hash).TrimEnd('='));
+            identifier.Replace('+', '.').Replace('/', '_');
+
+            return identifier.ToString();
+        }
+
+        /// <summary>
+        /// Return an identifier based on provided file or directory name
+        /// </summary>
+        /// <param name="name">File/directory name to generate identifer from</param>
+        /// <returns>A version of the name that is a legal identifier.</returns>
+        internal static string GetIdentifierFromName(string name)
+        {
+            string result = IllegalIdentifierCharacters.Replace(name, "_"); // replace illegal characters with "_".
+
+            // MSI identifiers must begin with an alphabetic character or an
+            // underscore. Prefix all other values with an underscore.
+            if (AddPrefix.IsMatch(name))
+            {
+                result = String.Concat("_", result);
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Checks if the string contains a property (i.e. "foo[Property]bar")
+        /// </summary>
+        /// <param name="possibleProperty">String to evaluate for properties.</param>
+        /// <returns>True if a property is found in the string.</returns>
+        internal static bool ContainsProperty(string possibleProperty)
+        {
+            return PropertySearch.IsMatch(possibleProperty);
+        }
+
+        /// <summary>
+        /// Recursively loops through a directory, changing an attribute on all of the underlying files.
+        /// An example is to add/remove the ReadOnly flag from each file.
+        /// </summary>
+        /// <param name="path">The directory path to start deleting from.</param>
+        /// <param name="fileAttribute">The FileAttribute to change on each file.</param>
+        /// <param name="messageHandler">The message handler.</param>
+        /// <param name="markAttribute">If true, add the attribute to each file. If false, remove it.</param>
+        private static void RecursiveFileAttributes(string path, FileAttributes fileAttribute, bool markAttribute, IMessageHandler messageHandler)
+        {
+            foreach (string subDirectory in Directory.GetDirectories(path))
+            {
+                RecursiveFileAttributes(subDirectory, fileAttribute, markAttribute, messageHandler);
+            }
+
+            foreach (string filePath in Directory.GetFiles(path))
+            {
+                FileAttributes attributes = File.GetAttributes(filePath);
+                if (markAttribute)
+                {
+                    attributes = attributes | fileAttribute; // add to list of attributes
+                }
+                else if (fileAttribute == (attributes & fileAttribute)) // if attribute set
+                {
+                    attributes = attributes ^ fileAttribute; // remove from list of attributes
+                }
+
+                try
+                {
+                    File.SetAttributes(filePath, attributes);
+                }
+                catch (UnauthorizedAccessException)
+                {
+                    messageHandler.OnMessage(WixWarnings.AccessDeniedForSettingAttributes(null, filePath));
+                }
+            }
+        }
+
+        internal static string GetFileHash(string path)
+        {
+            using (SHA1Managed managed = new SHA1Managed())
+            {
+                using (FileStream stream = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Delete | FileShare.Read))
+                {
+                    byte[] hash = managed.ComputeHash(stream);
+                    return BitConverter.ToString(hash).Replace("-", String.Empty);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Get an attribute value.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information about the owner element.</param>
+        /// <param name="attribute">The attribute containing the value to get.</param>
+        /// <param name="emptyRule">A rule for the contents of the value. If the contents do not follow the rule, an error is thrown.</param>
+        /// <param name="messageHandler">A delegate that receives error messages.</param>
+        /// <returns>The attribute's value.</returns>
+        internal static string GetAttributeValue(SourceLineNumber sourceLineNumbers, XAttribute attribute, EmptyRule emptyRule)
+        {
+            string value = attribute.Value;
+
+            if ((emptyRule == EmptyRule.MustHaveNonWhitespaceCharacters && String.IsNullOrEmpty(value.Trim())) ||
+                (emptyRule == EmptyRule.CanBeWhitespaceOnly && String.IsNullOrEmpty(value)))
+            {
+                Messaging.Instance.OnMessage(WixErrors.IllegalEmptyAttributeValue(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName));
+                return String.Empty;
+            }
+
+            return value;
+        }
+
+        /// <summary>
+        /// Verifies that a value is a legal identifier.
+        /// </summary>
+        /// <param name="value">The value to verify.</param>
+        /// <returns>true if the value is an identifier; false otherwise.</returns>
+        public static bool IsIdentifier(string value)
+        {
+            if (!String.IsNullOrEmpty(value))
+            {
+                if (LegalIdentifierCharacters.IsMatch(value))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Get an identifier attribute value and displays an error for an illegal identifier value.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information about the owner element.</param>
+        /// <param name="attribute">The attribute containing the value to get.</param>
+        /// <param name="messageHandler">A delegate that receives error messages.</param>
+        /// <returns>The attribute's identifier value or a special value if an error occurred.</returns>
+        internal static string GetAttributeIdentifierValue(SourceLineNumber sourceLineNumbers, XAttribute attribute)
+        {
+            string value = Common.GetAttributeValue(sourceLineNumbers, attribute, EmptyRule.CanBeWhitespaceOnly);
+
+            if (Common.IsIdentifier(value))
+            {
+                if (72 < value.Length)
+                {
+                    Messaging.Instance.OnMessage(WixWarnings.IdentifierTooLong(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value));
+                }
+
+                return value;
+            }
+            else
+            {
+                if (value.StartsWith("[", StringComparison.Ordinal) && value.EndsWith("]", StringComparison.Ordinal))
+                {
+                    Messaging.Instance.OnMessage(WixErrors.IllegalIdentifierLooksLikeFormatted(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value));
+                }
+                else
+                {
+                    Messaging.Instance.OnMessage(WixErrors.IllegalIdentifier(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value));
+                }
+
+                return String.Empty;
+            }
+        }
+
+        /// <summary>
+        /// Get an integer attribute value and displays an error for an illegal integer value.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information about the owner element.</param>
+        /// <param name="attribute">The attribute containing the value to get.</param>
+        /// <param name="minimum">The minimum legal value.</param>
+        /// <param name="maximum">The maximum legal value.</param>
+        /// <param name="messageHandler">A delegate that receives error messages.</param>
+        /// <returns>The attribute's integer value or a special value if an error occurred during conversion.</returns>
+        public static int GetAttributeIntegerValue(SourceLineNumber sourceLineNumbers, XAttribute attribute, int minimum, int maximum)
+        {
+            Debug.Assert(minimum > CompilerConstants.IntegerNotSet && minimum > CompilerConstants.IllegalInteger, "The legal values for this attribute collide with at least one sentinel used during parsing.");
+
+            string value = Common.GetAttributeValue(sourceLineNumbers, attribute, EmptyRule.CanBeWhitespaceOnly);
+            int integer = CompilerConstants.IllegalInteger;
+
+            if (0 < value.Length)
+            {
+                if (Int32.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture.NumberFormat, out integer))
+                {
+                    if (CompilerConstants.IntegerNotSet == integer || CompilerConstants.IllegalInteger == integer)
+                    {
+                        Messaging.Instance.OnMessage(WixErrors.IntegralValueSentinelCollision(sourceLineNumbers, integer));
+                    }
+                    else if (minimum > integer || maximum < integer)
+                    {
+                        Messaging.Instance.OnMessage(WixErrors.IntegralValueOutOfRange(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, integer, minimum, maximum));
+                        integer = CompilerConstants.IllegalInteger;
+                    }
+                }
+                else
+                {
+                    Messaging.Instance.OnMessage(WixErrors.IllegalIntegerValue(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value));
+                }
+            }
+
+            return integer;
+        }
+
+        /// <summary>
+        /// Gets a yes/no value and displays an error for an illegal yes/no value.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information about the owner element.</param>
+        /// <param name="attribute">The attribute containing the value to get.</param>
+        /// <param name="messageHandler">A delegate that receives error messages.</param>
+        /// <returns>The attribute's YesNoType value.</returns>
+        internal static YesNoType GetAttributeYesNoValue(SourceLineNumber sourceLineNumbers, XAttribute attribute)
+        {
+            string value = Common.GetAttributeValue(sourceLineNumbers, attribute, EmptyRule.CanBeWhitespaceOnly);
+            YesNoType yesNo = YesNoType.IllegalValue;
+
+            if ("yes".Equals(value) || "true".Equals(value))
+            {
+                yesNo = YesNoType.Yes;
+            }
+            else if ("no".Equals(value) || "false".Equals(value))
+            {
+                yesNo = YesNoType.No;
+            }
+            else
+            {
+                Messaging.Instance.OnMessage(WixErrors.IllegalYesNoValue(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value));
+            }
+
+            return yesNo;
+        }
+
+        /// <summary>
+        /// Gets the text of an XElement.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information about the owner element.</param>
+        /// <param name="attribute">The attribute containing the value to get.</param>
+        /// <param name="messageHandler">A delegate that receives error messages.</param>
+        /// <returns>The attribute's YesNoType value.</returns>
+        internal static string GetInnerText(XElement node)
+        {
+            XText text = node.Nodes().Where(n => XmlNodeType.Text == n.NodeType || XmlNodeType.CDATA == n.NodeType).Cast<XText>().FirstOrDefault();
+            return (null == text) ? null : text.Value;
+        }
+
+        /// <summary>
+        /// Display an unexpected attribute error.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information about the owner element.</param>
+        /// <param name="attribute">The attribute.</param>
+        public static void UnexpectedAttribute(SourceLineNumber sourceLineNumbers, XAttribute attribute)
+        {
+            // Ignore elements defined by the W3C because we'll assume they are always right.
+            if (!((String.IsNullOrEmpty(attribute.Name.NamespaceName) && attribute.Name.LocalName.Equals("xmlns", StringComparison.Ordinal)) ||
+                 attribute.Name.NamespaceName.StartsWith(CompilerCore.W3SchemaPrefix.NamespaceName, StringComparison.Ordinal)))
+            {
+                Messaging.Instance.OnMessage(WixErrors.UnexpectedAttribute(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName));
+            }
+        }
+
+        /// <summary>
+        /// Display an unsupported extension attribute error.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information about the owner element.</param>
+        /// <param name="extensionAttribute">The extension attribute.</param>
+        internal static void UnsupportedExtensionAttribute(SourceLineNumber sourceLineNumbers, XAttribute extensionAttribute)
+        {
+            // Ignore elements defined by the W3C because we'll assume they are always right.
+            if (!((String.IsNullOrEmpty(extensionAttribute.Name.NamespaceName) && extensionAttribute.Name.LocalName.Equals("xmlns", StringComparison.Ordinal)) ||
+                   extensionAttribute.Name.NamespaceName.StartsWith(CompilerCore.W3SchemaPrefix.NamespaceName, StringComparison.Ordinal)))
+            {
+                Messaging.Instance.OnMessage(WixErrors.UnsupportedExtensionAttribute(sourceLineNumbers, extensionAttribute.Parent.Name.LocalName, extensionAttribute.Name.LocalName));
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Compiler.cs b/src/WixToolset.Core/Compiler.cs
new file mode 100644
index 00000000..00618152
--- /dev/null
+++ b/src/WixToolset.Core/Compiler.cs
@@ -0,0 +1,20667 @@
+// 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
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Globalization;
+    using System.IO;
+    using System.Text.RegularExpressions;
+    using System.Xml.Linq;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+    using WixToolset.Extensibility;
+    using WixToolset.Msi;
+    using WixToolset.Core.Native;
+    using Wix = WixToolset.Data.Serialize;
+
+    /// <summary>
+    /// Compiler of the WiX toolset.
+    /// </summary>
+    [SuppressMessage("Microsoft.Naming", "CA1724:TypeNamesShouldNotMatchNamespaces")]
+    public sealed class Compiler
+    {
+        public const string UpgradeDetectedProperty = "WIX_UPGRADE_DETECTED";
+        public const string UpgradePreventedCondition = "NOT WIX_UPGRADE_DETECTED";
+        public const string DowngradeDetectedProperty = "WIX_DOWNGRADE_DETECTED";
+        public const string DowngradePreventedCondition = "NOT WIX_DOWNGRADE_DETECTED";
+        public const string DefaultComponentIdPlaceholderFormat = "WixComponentIdPlaceholder{0}";
+        public const string DefaultComponentIdPlaceholderWixVariableFormat = "!(wix.{0})";
+        public const string BurnUXContainerId = "WixUXContainer";
+        public const string BurnDefaultAttachedContainerId = "WixAttachedContainer";
+
+        // The following constants must stay in sync with src\burn\engine\core.h
+        private const string BURN_BUNDLE_NAME = "WixBundleName";
+        private const string BURN_BUNDLE_ORIGINAL_SOURCE = "WixBundleOriginalSource";
+        private const string BURN_BUNDLE_ORIGINAL_SOURCE_FOLDER = "WixBundleOriginalSourceFolder";
+        private const string BURN_BUNDLE_LAST_USED_SOURCE = "WixBundleLastUsedSource";
+
+        private TableDefinitionCollection tableDefinitions;
+        private Dictionary<XNamespace, ICompilerExtension> extensions;
+        private List<InspectorExtension> inspectorExtensions;
+        private CompilerCore core;
+        private bool showPedanticMessages;
+
+        // if these are true you know you are building a module or product
+        // but if they are false you cannot not be sure they will not end
+        // up a product or module.  Use these flags carefully.
+        private bool compilingModule;
+        private bool compilingProduct;
+
+        private bool useShortFileNames;
+        private string activeName;
+        private string activeLanguage;
+
+        private WixVariableResolver componentIdPlaceholdersResolver;
+
+        /// <summary>
+        /// Creates a new compiler object with a default set of table definitions.
+        /// </summary>
+        public Compiler()
+        {
+            this.tableDefinitions = new TableDefinitionCollection(WindowsInstallerStandard.GetTableDefinitions());
+            this.extensions = new Dictionary<XNamespace, ICompilerExtension>();
+            this.inspectorExtensions = new List<InspectorExtension>();
+
+            this.CurrentPlatform = Platform.X86;
+        }
+
+        /// <summary>
+        /// Type of RadioButton element in a group.
+        /// </summary>
+        private enum RadioButtonType
+        {
+            /// <summary>Not set, yet.</summary>
+            NotSet,
+
+            /// <summary>Text</summary>
+            Text,
+
+            /// <summary>Bitmap</summary>
+            Bitmap,
+
+            /// <summary>Icon</summary>
+            Icon,
+        }
+
+        /// <summary>
+        /// Gets or sets the platform which the compiler will use when defaulting 64-bit attributes and elements.
+        /// </summary>
+        /// <value>The platform which the compiler will use when defaulting 64-bit attributes and elements.</value>
+        public Platform CurrentPlatform { get; set; }
+
+        /// <summary>
+        /// Gets or sets the option to show pedantic messages.
+        /// </summary>
+        /// <value>The option to show pedantic messages.</value>
+        public bool ShowPedanticMessages
+        {
+            get { return this.showPedanticMessages; }
+            set { this.showPedanticMessages = value; }
+        }
+
+        /// <summary>
+        /// Adds a compiler extension.
+        /// </summary>
+        /// <param name="extension">The extension to add.</param>
+        public void AddExtension(ICompilerExtension extension)
+        {
+            // Check if this extension is adding a schema namespace that already exists.
+            ICompilerExtension collidingExtension;
+            if (!this.extensions.TryGetValue(extension.Namespace, out collidingExtension))
+            {
+                this.extensions.Add(extension.Namespace, extension);
+            }
+            else
+            {
+                Messaging.Instance.OnMessage(WixErrors.DuplicateExtensionXmlSchemaNamespace(extension.GetType().ToString(), extension.Namespace.NamespaceName, collidingExtension.GetType().ToString()));
+            }
+
+            //if (null != extension.InspectorExtension)
+            //{
+            //    this.inspectorExtensions.Add(extension.InspectorExtension);
+            //}
+        }
+
+        /// <summary>
+        /// Adds table definitions from an extension
+        /// </summary>
+        /// <param name="extension">Extension with table definitions.</param>
+        public void AddExtensionData(IExtensionData extension)
+        {
+            if (null != extension.TableDefinitions)
+            {
+                foreach (TableDefinition tableDefinition in extension.TableDefinitions)
+                {
+                    if (!this.tableDefinitions.Contains(tableDefinition.Name))
+                    {
+                        this.tableDefinitions.Add(tableDefinition);
+                    }
+                    else
+                    {
+                        Messaging.Instance.OnMessage(WixErrors.DuplicateExtensionTable(extension.GetType().ToString(), tableDefinition.Name));
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Compiles the provided Xml document into an intermediate object
+        /// </summary>
+        /// <param name="source">Source xml document to compile.  The BaseURI property
+        /// should be properly set to get messages containing source line information.</param>
+        /// <returns>Intermediate object representing compiled source document.</returns>
+        /// <remarks>This method is not thread-safe.</remarks>
+        [SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes")]
+        public Intermediate Compile(XDocument source)
+        {
+            if (null == source)
+            {
+                throw new ArgumentNullException("source");
+            }
+
+            bool encounteredError = false;
+
+            // create the intermediate
+            Intermediate target = new Intermediate();
+
+            // try to compile it
+            try
+            {
+                this.core = new CompilerCore(target, this.tableDefinitions, this.extensions);
+                this.core.ShowPedanticMessages = this.showPedanticMessages;
+                this.core.CurrentPlatform = this.CurrentPlatform;
+                this.componentIdPlaceholdersResolver = new WixVariableResolver();
+
+                foreach (CompilerExtension extension in this.extensions.Values)
+                {
+                    extension.Core = this.core;
+                    extension.Initialize();
+                }
+
+                // parse the document
+                SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(source.Root);
+                if ("Wix" == source.Root.Name.LocalName)
+                {
+                    if (CompilerCore.WixNamespace == source.Root.Name.Namespace)
+                    {
+                        this.ParseWixElement(source.Root);
+                    }
+                    else // invalid or missing namespace
+                    {
+                        if (String.IsNullOrEmpty(source.Root.Name.NamespaceName))
+                        {
+                            this.core.OnMessage(WixErrors.InvalidWixXmlNamespace(sourceLineNumbers, "Wix", CompilerCore.WixNamespace.ToString()));
+                        }
+                        else
+                        {
+                            this.core.OnMessage(WixErrors.InvalidWixXmlNamespace(sourceLineNumbers, "Wix", source.Root.Name.NamespaceName, CompilerCore.WixNamespace.ToString()));
+                        }
+                    }
+                }
+                else
+                {
+                    this.core.OnMessage(WixErrors.InvalidDocumentElement(sourceLineNumbers, source.Root.Name.LocalName, "source", "Wix"));
+                }
+
+                // Resolve any Component Id placeholders compiled into the intermediate.
+                if (0 < this.componentIdPlaceholdersResolver.VariableCount)
+                {
+                    foreach (var section in target.Sections)
+                    {
+                        foreach (Table table in section.Tables)
+                        {
+                            foreach (Row row in table.Rows)
+                            {
+                                foreach (Field field in row.Fields)
+                                {
+                                    if (field.Data is string)
+                                    {
+                                        bool isDefault = false;
+                                        bool delayedResolve = false;
+                                        field.Data = this.componentIdPlaceholdersResolver.ResolveVariables(row.SourceLineNumbers, (string)field.Data, false, false, ref isDefault, ref delayedResolve);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                // inspect the document
+                InspectorCore inspectorCore = new InspectorCore();
+                foreach (InspectorExtension inspectorExtension in this.inspectorExtensions)
+                {
+                    inspectorExtension.Core = inspectorCore;
+                    inspectorExtension.InspectIntermediate(target);
+
+                    // reset
+                    inspectorExtension.Core = null;
+                }
+
+                if (inspectorCore.EncounteredError)
+                {
+                    encounteredError = true;
+                }
+            }
+            finally
+            {
+                if (this.core.EncounteredError)
+                {
+                    encounteredError = true;
+                }
+
+                foreach (CompilerExtension extension in this.extensions.Values)
+                {
+                    extension.Finish();
+                    extension.Core = null;
+                }
+                this.core = null;
+            }
+
+            // return the compiled intermediate only if it completed successfully
+            return (encounteredError ? null : target);
+        }
+
+        /// <summary>
+        /// Uppercases the first character of a string.
+        /// </summary>
+        /// <param name="s">String to uppercase first character of.</param>
+        /// <returns>String with first character uppercased.</returns>
+        private static string UppercaseFirstChar(string s)
+        {
+            if (0 == s.Length)
+            {
+                return s;
+            }
+
+            return String.Concat(s.Substring(0, 1).ToUpper(CultureInfo.InvariantCulture), s.Substring(1));
+        }
+
+        /// <summary>
+        /// Lowercases the string if present.
+        /// </summary>
+        /// <param name="s">String to lowercase.</param>
+        /// <returns>Null if the string is null, otherwise returns the lowercase.</returns>
+        private static string LowercaseOrNull(string s)
+        {
+            return (null == s) ? s : s.ToLowerInvariant();
+        }
+
+        /// <summary>
+        /// Given a possible short and long file name, create an msi filename value.
+        /// </summary>
+        /// <param name="shortName">The short file name.</param>
+        /// <param name="longName">Possibly the long file name.</param>
+        /// <returns>The value in the msi filename data type.</returns>
+        private string GetMsiFilenameValue(string shortName, string longName)
+        {
+            if (null != shortName && null != longName && !String.Equals(shortName, longName, StringComparison.OrdinalIgnoreCase))
+            {
+                return String.Format(CultureInfo.InvariantCulture, "{0}|{1}", shortName, longName);
+            }
+            else
+            {
+                if (this.core.IsValidShortFilename(longName, false))
+                {
+                    return longName;
+                }
+                else
+                {
+                    return shortName;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Adds a search property to the active section.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Current source/line number of processing.</param>
+        /// <param name="property">Property to add to search.</param>
+        /// <param name="signature">Signature for search.</param>
+        private void AddAppSearch(SourceLineNumber sourceLineNumbers, Identifier property, string signature)
+        {
+            if (!this.core.EncounteredError)
+            {
+                if (property.Id != property.Id.ToUpperInvariant())
+                {
+                    this.core.OnMessage(WixErrors.SearchPropertyNotUppercase(sourceLineNumbers, "Property", "Id", property.Id));
+                }
+
+                Row row = this.core.CreateRow(sourceLineNumbers, "AppSearch", property);
+                row[1] = signature;
+            }
+        }
+
+        /// <summary>
+        /// Adds a property to the active section.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Current source/line number of processing.</param>
+        /// <param name="property">Name of property to add.</param>
+        /// <param name="value">Value of property.</param>
+        /// <param name="admin">Flag if property is an admin property.</param>
+        /// <param name="secure">Flag if property is a secure property.</param>
+        /// <param name="hidden">Flag if property is to be hidden.</param>
+        /// <param name="fragment">Adds the property to a new section.</param>
+        private void AddProperty(SourceLineNumber sourceLineNumbers, Identifier property, string value, bool admin, bool secure, bool hidden, bool fragment)
+        {
+            // properties without a valid identifier should not be processed any further
+            if (null == property || String.IsNullOrEmpty(property.Id))
+            {
+                return;
+            }
+
+            if (!String.IsNullOrEmpty(value))
+            {
+                Regex regex = new Regex(@"\[(?<identifier>[a-zA-Z_][a-zA-Z0-9_\.]*)]", RegexOptions.Compiled | RegexOptions.Singleline | RegexOptions.ExplicitCapture);
+                MatchCollection matches = regex.Matches(value);
+
+                foreach (Match match in matches)
+                {
+                    Group group = match.Groups["identifier"];
+                    if (group.Success)
+                    {
+                        this.core.OnMessage(WixWarnings.PropertyValueContainsPropertyReference(sourceLineNumbers, property.Id, group.Value));
+                    }
+                }
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                Section section = this.core.ActiveSection;
+
+                // Add the row to a separate section if requested.
+                if (fragment)
+                {
+                    string id = String.Concat(this.core.ActiveSection.Id, ".", property.Id);
+
+                    section = this.core.CreateSection(id, SectionType.Fragment, this.core.ActiveSection.Codepage);
+
+                    // Reference the property in the active section.
+                    this.core.CreateSimpleReference(sourceLineNumbers, "Property", property.Id);
+                }
+
+                Row row = this.core.CreateRow(sourceLineNumbers, "Property", section, property);
+
+                // Allow row to exist with no value so that PropertyRefs can be made for *Search elements
+                // the linker will remove these rows before the final output is created.
+                if (null != value)
+                {
+                    row[1] = value;
+                }
+
+                if (admin || hidden || secure)
+                {
+                    this.AddWixPropertyRow(sourceLineNumbers, property, admin, secure, hidden, section);
+                }
+            }
+        }
+
+        private WixPropertyRow AddWixPropertyRow(SourceLineNumber sourceLineNumbers, Identifier property, bool admin, bool secure, bool hidden, Section section = null)
+        {
+            if (secure && property.Id != property.Id.ToUpperInvariant())
+            {
+                this.core.OnMessage(WixErrors.SecurePropertyNotUppercase(sourceLineNumbers, "Property", "Id", property.Id));
+            }
+
+            if (null == section)
+            {
+                section = this.core.ActiveSection;
+
+                this.core.EnsureTable(sourceLineNumbers, "Property"); // Property table is always required when using WixProperty table.
+            }
+
+            WixPropertyRow row = (WixPropertyRow)this.core.CreateRow(sourceLineNumbers, "WixProperty", section, property);
+            row.Admin = admin;
+            row.Hidden = hidden;
+            row.Secure = secure;
+
+            return row;
+        }
+
+        /// <summary>
+        /// Adds a "implemented category" registry key to active section.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Current source/line number of processing.</param>
+        /// <param name="categoryId">GUID for category.</param>
+        /// <param name="classId">ClassId for to mark "implemented".</param>
+        /// <param name="componentId">Identifier of parent component.</param>
+        private void RegisterImplementedCategories(SourceLineNumber sourceLineNumbers, string categoryId, string classId, string componentId)
+        {
+            this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("CLSID\\", classId, "\\Implemented Categories\\", categoryId), "*", null, componentId);
+        }
+
+        /// <summary>
+        /// Parses an application identifer element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="componentId">Identifier of parent component.</param>
+        /// <param name="advertise">The required advertise state (set depending upon the parent).</param>
+        /// <param name="fileServer">Optional file identifier for CLSID when not advertised.</param>
+        /// <param name="typeLibId">Optional TypeLib GUID for CLSID.</param>
+        /// <param name="typeLibVersion">Optional TypeLib Version for CLSID Interfaces (if any).</param>
+        private void ParseAppIdElement(XElement node, string componentId, YesNoType advertise, string fileServer, string typeLibId, string typeLibVersion)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string appId = null;
+            string remoteServerName = null;
+            string localService = null;
+            string serviceParameters = null;
+            string dllSurrogate = null;
+            YesNoType activateAtStorage = YesNoType.NotSet;
+            YesNoType appIdAdvertise = YesNoType.NotSet;
+            YesNoType runAsInteractiveUser = YesNoType.NotSet;
+            string description = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            appId = this.core.GetAttributeGuidValue(sourceLineNumbers, attrib, false);
+                            break;
+                        case "ActivateAtStorage":
+                            activateAtStorage = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Advertise":
+                            appIdAdvertise = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Description": description = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "DllSurrogate":
+                            dllSurrogate = this.core.GetAttributeValue(sourceLineNumbers, attrib, EmptyRule.CanBeEmpty);
+                            break;
+                        case "LocalService":
+                            localService = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "RemoteServerName":
+                            remoteServerName = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "RunAsInteractiveUser":
+                            runAsInteractiveUser = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ServiceParameters":
+                            serviceParameters = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == appId)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            if ((YesNoType.No == advertise && YesNoType.Yes == appIdAdvertise) || (YesNoType.Yes == advertise && YesNoType.No == appIdAdvertise))
+            {
+                this.core.OnMessage(WixErrors.AppIdIncompatibleAdvertiseState(sourceLineNumbers, node.Name.LocalName, "Advertise", appIdAdvertise.ToString(), advertise.ToString()));
+            }
+            else
+            {
+                advertise = appIdAdvertise;
+            }
+
+            // if the advertise state has not been set, default to non-advertised
+            if (YesNoType.NotSet == advertise)
+            {
+                advertise = YesNoType.No;
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "Class":
+                            this.ParseClassElement(child, componentId, advertise, fileServer, typeLibId, typeLibVersion, appId);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (YesNoType.Yes == advertise)
+            {
+                if (null != description)
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeWhenAdvertised(sourceLineNumbers, node.Name.LocalName, "Description"));
+                }
+
+                if (!this.core.EncounteredError)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "AppId");
+                    row[0] = appId;
+                    row[1] = remoteServerName;
+                    row[2] = localService;
+                    row[3] = serviceParameters;
+                    row[4] = dllSurrogate;
+                    if (YesNoType.Yes == activateAtStorage)
+                    {
+                        row[5] = 1;
+                    }
+
+                    if (YesNoType.Yes == runAsInteractiveUser)
+                    {
+                        row[6] = 1;
+                    }
+                }
+            }
+            else if (YesNoType.No == advertise)
+            {
+                if (null != description)
+                {
+                    this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("AppID\\", appId), null, description, componentId);
+                }
+                else
+                {
+                    this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("AppID\\", appId), "+", null, componentId);
+                }
+
+                if (null != remoteServerName)
+                {
+                    this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("AppID\\", appId), "RemoteServerName", remoteServerName, componentId);
+                }
+
+                if (null != localService)
+                {
+                    this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("AppID\\", appId), "LocalService", localService, componentId);
+                }
+
+                if (null != serviceParameters)
+                {
+                    this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("AppID\\", appId), "ServiceParameters", serviceParameters, componentId);
+                }
+
+                if (null != dllSurrogate)
+                {
+                    this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("AppID\\", appId), "DllSurrogate", dllSurrogate, componentId);
+                }
+
+                if (YesNoType.Yes == activateAtStorage)
+                {
+                    this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("AppID\\", appId), "ActivateAtStorage", "Y", componentId);
+                }
+
+                if (YesNoType.Yes == runAsInteractiveUser)
+                {
+                    this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("AppID\\", appId), "RunAs", "Interactive User", componentId);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses an AssemblyName element.
+        /// </summary>
+        /// <param name="node">File element to parse.</param>
+        /// <param name="componentId">Parent's component id.</param>
+        private void ParseAssemblyName(XElement node, string componentId)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string id = null;
+            string value = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Value":
+                            value = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "MsiAssemblyName");
+                row[0] = componentId;
+                row[1] = id;
+                row[2] = value;
+            }
+        }
+
+        /// <summary>
+        /// Parses a binary element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <returns>Identifier for the new row.</returns>
+        [SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")]
+        private Identifier ParseBinaryElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            string sourceFile = null;
+            YesNoType suppressModularization = YesNoType.NotSet;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "SourceFile":
+                        case "src":
+                            if (null != sourceFile)
+                            {
+                                this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "SourceFile", "src"));
+                            }
+
+                            if ("src" == attrib.Name.LocalName)
+                            {
+                                this.core.OnMessage(WixWarnings.DeprecatedAttribute(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, "SourceFile"));
+                            }
+                            sourceFile = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "SuppressModularization":
+                            suppressModularization = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+                id = Identifier.Invalid;
+            }
+            else if (!String.IsNullOrEmpty(id.Id)) // only check legal values
+            {
+                if (55 < id.Id.Length)
+                {
+                    this.core.OnMessage(WixErrors.StreamNameTooLong(sourceLineNumbers, node.Name.LocalName, "Id", id.Id, id.Id.Length, 55));
+                }
+                else if (!this.compilingProduct) // if we're not doing a product then we can't be sure that a binary identifier will fit when modularized
+                {
+                    if (18 < id.Id.Length)
+                    {
+                        this.core.OnMessage(WixWarnings.IdentifierCannotBeModularized(sourceLineNumbers, node.Name.LocalName, "Id", id.Id, id.Id.Length, 18));
+                    }
+                }
+            }
+
+            if (null == sourceFile)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "SourceFile"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "Binary", id);
+                row[1] = sourceFile;
+
+                if (YesNoType.Yes == suppressModularization)
+                {
+                    Row wixSuppressModularizationRow = this.core.CreateRow(sourceLineNumbers, "WixSuppressModularization");
+                    wixSuppressModularizationRow[0] = id;
+                }
+            }
+
+            return id;
+        }
+
+        /// <summary>
+        /// Parses an icon element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <returns>Identifier for the new row.</returns>
+        private string ParseIconElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            string sourceFile = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "SourceFile":
+                            sourceFile = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+                id = Identifier.Invalid;
+            }
+            else if (!String.IsNullOrEmpty(id.Id)) // only check legal values
+            {
+                if (57 < id.Id.Length)
+                {
+                    this.core.OnMessage(WixErrors.StreamNameTooLong(sourceLineNumbers, node.Name.LocalName, "Id", id.Id, id.Id.Length, 57));
+                }
+                else if (!this.compilingProduct) // if we're not doing a product then we can't be sure that a binary identifier will fit when modularized
+                {
+                    if (20 < id.Id.Length)
+                    {
+                        this.core.OnMessage(WixWarnings.IdentifierCannotBeModularized(sourceLineNumbers, node.Name.LocalName, "Id", id.Id, id.Id.Length, 20));
+                    }
+                }
+            }
+
+            if (null == sourceFile)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "SourceFile"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "Icon", id);
+                row[1] = sourceFile;
+            }
+
+            return id.Id;
+        }
+
+        /// <summary>
+        /// Parses an InstanceTransforms element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        private void ParseInstanceTransformsElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string property = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Property":
+                            property = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.core.CreateSimpleReference(sourceLineNumbers, "Property", property);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == property)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Property"));
+            }
+
+            // find unexpected child elements
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "Instance":
+                            ParseInstanceElement(child, property);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses an instance element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="componentId">Identifier of instance property.</param>
+        private void ParseInstanceElement(XElement node, string propertyId)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string id = null;
+            string productCode = null;
+            string productName = null;
+            string upgradeCode = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ProductCode":
+                            productCode = this.core.GetAttributeGuidValue(sourceLineNumbers, attrib, true);
+                            break;
+                        case "ProductName":
+                            productName = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "UpgradeCode":
+                            upgradeCode = this.core.GetAttributeGuidValue(sourceLineNumbers, attrib, false);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            if (null == productCode)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "ProductCode"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "WixInstanceTransforms");
+                row[0] = id;
+                row[1] = propertyId;
+                row[2] = productCode;
+                if (null != productName)
+                {
+                    row[3] = productName;
+                }
+                if (null != upgradeCode)
+                {
+                    row[4] = upgradeCode;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses a category element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="componentId">Identifier of parent component.</param>
+        private void ParseCategoryElement(XElement node, string componentId)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string id = null;
+            string appData = null;
+            string feature = null;
+            string qualifier = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeGuidValue(sourceLineNumbers, attrib, false);
+                            break;
+                        case "AppData":
+                            appData = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Feature":
+                            feature = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.core.CreateSimpleReference(sourceLineNumbers, "Feature", feature);
+                            break;
+                        case "Qualifier":
+                            qualifier = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            if (null == qualifier)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Qualifier"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "PublishComponent");
+                row[0] = id;
+                row[1] = qualifier;
+                row[2] = componentId;
+                row[3] = appData;
+                if (null == feature)
+                {
+                    row[4] = Guid.Empty.ToString("B");
+                }
+                else
+                {
+                    row[4] = feature;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses a class element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="componentId">Identifier of parent component.</param>
+        /// <param name="advertise">Optional Advertise State for the parent AppId element (if any).</param>
+        /// <param name="fileServer">Optional file identifier for CLSID when not advertised.</param>
+        /// <param name="typeLibId">Optional TypeLib GUID for CLSID.</param>
+        /// <param name="typeLibVersion">Optional TypeLib Version for CLSID Interfaces (if any).</param>
+        /// <param name="parentAppId">Optional parent AppId.</param>
+        private void ParseClassElement(XElement node, string componentId, YesNoType advertise, string fileServer, string typeLibId, string typeLibVersion, string parentAppId)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+
+            string appId = null;
+            string argument = null;
+            bool class16bit = false;
+            bool class32bit = false;
+            string classId = null;
+            YesNoType classAdvertise = YesNoType.NotSet;
+            string[] contexts = null;
+            string formattedContextString = null;
+            bool control = false;
+            string defaultInprocHandler = null;
+            string defaultProgId = null;
+            string description = null;
+            string fileTypeMask = null;
+            string foreignServer = null;
+            string icon = null;
+            int iconIndex = CompilerConstants.IntegerNotSet;
+            string insertable = null;
+            string localFileServer = null;
+            bool programmable = false;
+            YesNoType relativePath = YesNoType.NotSet;
+            bool safeForInit = false;
+            bool safeForScripting = false;
+            bool shortServerPath = false;
+            string threadingModel = null;
+            string version = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            classId = this.core.GetAttributeGuidValue(sourceLineNumbers, attrib, false);
+                            break;
+                        case "Advertise":
+                            classAdvertise = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "AppId":
+                            appId = this.core.GetAttributeGuidValue(sourceLineNumbers, attrib, false);
+                            break;
+                        case "Argument":
+                            argument = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Context":
+                            contexts = this.core.GetAttributeValue(sourceLineNumbers, attrib).Split("\r\n\t ".ToCharArray(), StringSplitOptions.RemoveEmptyEntries);
+                            break;
+                        case "Control":
+                            control = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Description":
+                            description = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Handler":
+                            defaultInprocHandler = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Icon":
+                            icon = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        case "IconIndex":
+                            iconIndex = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, short.MinValue + 1, short.MaxValue);
+                            break;
+                        case "RelativePath":
+                            relativePath = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+
+                        // The following attributes result in rows always added to the Registry table rather than the Class table
+                        case "Insertable":
+                            insertable = (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib)) ? "Insertable" : "NotInsertable";
+                            break;
+                        case "Programmable":
+                            programmable = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "SafeForInitializing":
+                            safeForInit = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "SafeForScripting":
+                            safeForScripting = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ForeignServer":
+                            foreignServer = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Server":
+                            localFileServer = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ShortPath":
+                            shortServerPath = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ThreadingModel":
+                            threadingModel = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Version":
+                            version = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == classId)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            HashSet<string> uniqueContexts = new HashSet<string>();
+            foreach (string context in contexts)
+            {
+                if (uniqueContexts.Contains(context))
+                {
+                    this.core.OnMessage(WixErrors.DuplicateContextValue(sourceLineNumbers, context));
+                }
+                else
+                {
+                    uniqueContexts.Add(context);
+                }
+
+                if (context.EndsWith("32", StringComparison.Ordinal))
+                {
+                    class32bit = true;
+                }
+                else
+                {
+                    class16bit = true;
+                }
+            }
+
+            if ((YesNoType.No == advertise && YesNoType.Yes == classAdvertise) || (YesNoType.Yes == advertise && YesNoType.No == classAdvertise))
+            {
+                this.core.OnMessage(WixErrors.AdvertiseStateMustMatch(sourceLineNumbers, classAdvertise.ToString(), advertise.ToString()));
+            }
+            else
+            {
+                advertise = classAdvertise;
+            }
+
+            // If the advertise state has not been set, default to non-advertised.
+            if (YesNoType.NotSet == advertise)
+            {
+                advertise = YesNoType.No;
+            }
+
+            if (YesNoType.Yes == advertise && 0 == contexts.Length)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Context", "Advertise", "yes"));
+            }
+
+            if (!String.IsNullOrEmpty(parentAppId) && !String.IsNullOrEmpty(appId))
+            {
+                this.core.OnMessage(WixErrors.IllegalAttributeWhenNested(sourceLineNumbers, node.Name.LocalName, "AppId", node.Parent.Name.LocalName));
+            }
+
+            if (!String.IsNullOrEmpty(localFileServer))
+            {
+                this.core.CreateSimpleReference(sourceLineNumbers, "File", localFileServer);
+            }
+
+            // Local variables used strictly for child node processing.
+            int fileTypeMaskIndex = 0;
+            YesNoType firstProgIdForClass = YesNoType.Yes;
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "FileTypeMask":
+                            if (YesNoType.Yes == advertise)
+                            {
+                                fileTypeMask = String.Concat(fileTypeMask, null == fileTypeMask ? String.Empty : ";", this.ParseFileTypeMaskElement(child));
+                            }
+                            else if (YesNoType.No == advertise)
+                            {
+                                SourceLineNumber childSourceLineNumbers = Preprocessor.GetSourceLineNumbers(child);
+                                this.core.CreateRegistryRow(childSourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("FileType\\", classId, "\\", fileTypeMaskIndex.ToString()), String.Empty, this.ParseFileTypeMaskElement(child), componentId);
+                                fileTypeMaskIndex++;
+                            }
+                            break;
+                        case "Interface":
+                            this.ParseInterfaceElement(child, componentId, class16bit ? classId : null, class32bit ? classId : null, typeLibId, typeLibVersion);
+                            break;
+                        case "ProgId":
+                            {
+                                bool foundExtension = false;
+                                string progId = this.ParseProgIdElement(child, componentId, advertise, classId, description, null, ref foundExtension, firstProgIdForClass);
+                                if (null == defaultProgId)
+                                {
+                                    defaultProgId = progId;
+                                }
+                                firstProgIdForClass = YesNoType.No;
+                            }
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            // If this Class is being advertised.
+            if (YesNoType.Yes == advertise)
+            {
+                if (null != fileServer || null != localFileServer)
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "Server", "Advertise", "yes"));
+                }
+
+                if (null != foreignServer)
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "ForeignServer", "Advertise", "yes"));
+                }
+
+                if (null == appId && null != parentAppId)
+                {
+                    appId = parentAppId;
+                }
+
+                // add a Class row for each context
+                if (!this.core.EncounteredError)
+                {
+                    foreach (string context in contexts)
+                    {
+                        Row row = this.core.CreateRow(sourceLineNumbers, "Class");
+                        row[0] = classId;
+                        row[1] = context;
+                        row[2] = componentId;
+                        row[3] = defaultProgId;
+                        row[4] = description;
+                        if (null != appId)
+                        {
+                            row[5] = appId;
+                            this.core.CreateSimpleReference(sourceLineNumbers, "AppId", appId);
+                        }
+                        row[6] = fileTypeMask;
+                        if (null != icon)
+                        {
+                            row[7] = icon;
+                            this.core.CreateSimpleReference(sourceLineNumbers, "Icon", icon);
+                        }
+                        if (CompilerConstants.IntegerNotSet != iconIndex)
+                        {
+                            row[8] = iconIndex;
+                        }
+                        row[9] = defaultInprocHandler;
+                        row[10] = argument;
+                        row[11] = Guid.Empty.ToString("B");
+                        if (YesNoType.Yes == relativePath)
+                        {
+                            row[12] = MsiInterop.MsidbClassAttributesRelativePath;
+                        }
+                    }
+                }
+            }
+            else if (YesNoType.No == advertise)
+            {
+                if (null == fileServer && null == localFileServer && null == foreignServer)
+                {
+                    this.core.OnMessage(WixErrors.ExpectedAttributes(sourceLineNumbers, node.Name.LocalName, "ForeignServer", "Server"));
+                }
+
+                if (null != fileServer && null != foreignServer)
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeWhenNested(sourceLineNumbers, node.Name.LocalName, "ForeignServer", "File"));
+                }
+                else if (null != localFileServer && null != foreignServer)
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "ForeignServer", "Server"));
+                }
+                else if (null == fileServer)
+                {
+                    fileServer = localFileServer;
+                }
+
+                if (null != appId) // need to use nesting (not a reference) for the unadvertised Class elements
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "AppId", "Advertise", "no"));
+                }
+
+                // add the core registry keys for each context in the class
+                foreach (string context in contexts)
+                {
+                    if (context.StartsWith("InprocServer", StringComparison.Ordinal)) // dll server
+                    {
+                        if (null != argument)
+                        {
+                            this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "Arguments", "Context", context));
+                        }
+
+                        if (null != fileServer)
+                        {
+                            formattedContextString = String.Concat("[", shortServerPath ? "!" : "#", fileServer, "]");
+                        }
+                        else if (null != foreignServer)
+                        {
+                            formattedContextString = foreignServer;
+                        }
+                    }
+                    else if (context.StartsWith("LocalServer", StringComparison.Ordinal)) // exe server (quote the long path)
+                    {
+                        if (null != fileServer)
+                        {
+                            if (shortServerPath)
+                            {
+                                formattedContextString = String.Concat("[!", fileServer, "]");
+                            }
+                            else
+                            {
+                                formattedContextString = String.Concat("\"[#", fileServer, "]\"");
+                            }
+                        }
+                        else if (null != foreignServer)
+                        {
+                            formattedContextString = foreignServer;
+                        }
+
+                        if (null != argument)
+                        {
+                            formattedContextString = String.Concat(formattedContextString, " ", argument);
+                        }
+                    }
+                    else
+                    {
+                        this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, "Context", context, "InprocServer", "InprocServer32", "LocalServer", "LocalServer32"));
+                    }
+
+                    this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("CLSID\\", classId, "\\", context), String.Empty, formattedContextString, componentId); // ClassId context
+
+                    if (null != icon) // ClassId default icon
+                    {
+                        this.core.CreateSimpleReference(sourceLineNumbers, "File", icon);
+
+                        icon = String.Format(CultureInfo.InvariantCulture, "\"[#{0}]\"", icon);
+
+                        if (CompilerConstants.IntegerNotSet != iconIndex)
+                        {
+                            icon = String.Concat(icon, ",", iconIndex);
+                        }
+                        this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("CLSID\\", classId, "\\", context, "\\DefaultIcon"), String.Empty, icon, componentId);
+                    }
+                }
+
+                if (null != parentAppId) // ClassId AppId (must be specified via nesting, not with the AppId attribute)
+                {
+                    this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("CLSID\\", classId), "AppID", parentAppId, componentId);
+                }
+
+                if (null != description) // ClassId description
+                {
+                    this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("CLSID\\", classId), String.Empty, description, componentId);
+                }
+
+                if (null != defaultInprocHandler)
+                {
+                    switch (defaultInprocHandler) // ClassId Default Inproc Handler
+                    {
+                        case "1":
+                            this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("CLSID\\", classId, "\\InprocHandler"), String.Empty, "ole.dll", componentId);
+                            break;
+                        case "2":
+                            this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("CLSID\\", classId, "\\InprocHandler32"), String.Empty, "ole32.dll", componentId);
+                            break;
+                        case "3":
+                            this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("CLSID\\", classId, "\\InprocHandler"), String.Empty, "ole.dll", componentId);
+                            this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("CLSID\\", classId, "\\InprocHandler32"), String.Empty, "ole32.dll", componentId);
+                            break;
+                        default:
+                            this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("CLSID\\", classId, "\\InprocHandler32"), String.Empty, defaultInprocHandler, componentId);
+                            break;
+                    }
+                }
+
+                if (YesNoType.NotSet != relativePath) // ClassId's RelativePath
+                {
+                    this.core.OnMessage(WixErrors.RelativePathForRegistryElement(sourceLineNumbers));
+                }
+            }
+
+            if (null != threadingModel)
+            {
+                threadingModel = Compiler.UppercaseFirstChar(threadingModel);
+
+                // add a threading model for each context in the class
+                foreach (string context in contexts)
+                {
+                    this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("CLSID\\", classId, "\\", context), "ThreadingModel", threadingModel, componentId);
+                }
+            }
+
+            if (null != typeLibId)
+            {
+                this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("CLSID\\", classId, "\\TypeLib"), null, typeLibId, componentId);
+            }
+
+            if (null != version)
+            {
+                this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("CLSID\\", classId, "\\Version"), null, version, componentId);
+            }
+
+            if (null != insertable)
+            {
+                // Add "*" for name so that any subkeys (shouldn't be any) are removed on uninstall.
+                this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("CLSID\\", classId, "\\", insertable), "*", null, componentId);
+            }
+
+            if (control)
+            {
+                // Add "*" for name so that any subkeys (shouldn't be any) are removed on uninstall.
+                this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("CLSID\\", classId, "\\Control"), "*", null, componentId);
+            }
+
+            if (programmable)
+            {
+                // Add "*" for name so that any subkeys (shouldn't be any) are removed on uninstall.
+                this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("CLSID\\", classId, "\\Programmable"), "*", null, componentId);
+            }
+
+            if (safeForInit)
+            {
+                this.RegisterImplementedCategories(sourceLineNumbers, "{7DD95802-9882-11CF-9FA9-00AA006C42C4}", classId, componentId);
+            }
+
+            if (safeForScripting)
+            {
+                this.RegisterImplementedCategories(sourceLineNumbers, "{7DD95801-9882-11CF-9FA9-00AA006C42C4}", classId, componentId);
+            }
+        }
+
+        /// <summary>
+        /// Parses an Interface element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="componentId">Identifier of parent component.</param>
+        /// <param name="proxyId">16-bit proxy for interface.</param>
+        /// <param name="proxyId32">32-bit proxy for interface.</param>
+        /// <param name="typeLibId">Optional TypeLib GUID for CLSID.</param>
+        /// <param name="typelibVersion">Version of the TypeLib to which this interface belongs.  Required if typeLibId is specified</param>
+        private void ParseInterfaceElement(XElement node, string componentId, string proxyId, string proxyId32, string typeLibId, string typelibVersion)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string baseInterface = null;
+            string interfaceId = null;
+            string name = null;
+            int numMethods = CompilerConstants.IntegerNotSet;
+            bool versioned = true;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            interfaceId = this.core.GetAttributeGuidValue(sourceLineNumbers, attrib, false);
+                            break;
+                        case "BaseInterface":
+                            baseInterface = this.core.GetAttributeGuidValue(sourceLineNumbers, attrib, false);
+                            break;
+                        case "Name":
+                            name = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "NumMethods":
+                            numMethods = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, int.MaxValue);
+                            break;
+                        case "ProxyStubClassId":
+                            proxyId = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ProxyStubClassId32":
+                            proxyId32 = this.core.GetAttributeGuidValue(sourceLineNumbers, attrib, false);
+                            break;
+                        case "Versioned":
+                            versioned = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == interfaceId)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            if (null == name)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Name"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("Interface\\", interfaceId), null, name, componentId);
+            if (null != typeLibId)
+            {
+                this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("Interface\\", interfaceId, "\\TypeLib"), null, typeLibId, componentId);
+                if (versioned)
+                {
+                    this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("Interface\\", interfaceId, "\\TypeLib"), "Version", typelibVersion, componentId);
+                }
+            }
+
+            if (null != baseInterface)
+            {
+                this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("Interface\\", interfaceId, "\\BaseInterface"), null, baseInterface, componentId);
+            }
+
+            if (CompilerConstants.IntegerNotSet != numMethods)
+            {
+                this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("Interface\\", interfaceId, "\\NumMethods"), null, numMethods.ToString(), componentId);
+            }
+
+            if (null != proxyId)
+            {
+                this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("Interface\\", interfaceId, "\\ProxyStubClsid"), null, proxyId, componentId);
+            }
+
+            if (null != proxyId32)
+            {
+                this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("Interface\\", interfaceId, "\\ProxyStubClsid32"), null, proxyId32, componentId);
+            }
+        }
+
+        /// <summary>
+        /// Parses a CLSID's file type mask element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <returns>String representing the file type mask elements.</returns>
+        private string ParseFileTypeMaskElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            int cb = 0;
+            int offset = CompilerConstants.IntegerNotSet;
+            string mask = null;
+            string value = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Mask":
+                            mask = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Offset":
+                            offset = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, int.MaxValue);
+                            break;
+                        case "Value":
+                            value = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+
+            if (null == mask)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Mask"));
+            }
+
+            if (CompilerConstants.IntegerNotSet == offset)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Offset"));
+            }
+
+            if (null == value)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Value"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                if (mask.Length != value.Length)
+                {
+                    this.core.OnMessage(WixErrors.ValueAndMaskMustBeSameLength(sourceLineNumbers));
+                }
+                cb = mask.Length / 2;
+            }
+
+            return String.Concat(offset.ToString(CultureInfo.InvariantCulture.NumberFormat), ",", cb.ToString(CultureInfo.InvariantCulture.NumberFormat), ",", mask, ",", value);
+        }
+
+        /// <summary>
+        /// Parses a product search element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <returns>Signature for search element.</returns>
+        private void ParseProductSearchElement(XElement node, string propertyId)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+
+            string upgradeCode = null;
+            string language = null;
+            string maximum = null;
+            string minimum = null;
+            int options = MsiInterop.MsidbUpgradeAttributesVersionMinInclusive | MsiInterop.MsidbUpgradeAttributesOnlyDetect;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "ExcludeLanguages":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                options |= MsiInterop.MsidbUpgradeAttributesLanguagesExclusive;
+                            }
+                            break;
+                        case "IncludeMaximum":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                options |= MsiInterop.MsidbUpgradeAttributesVersionMaxInclusive;
+                            }
+                            break;
+                        case "IncludeMinimum": // this is "yes" by default
+                            if (YesNoType.No == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                options &= ~MsiInterop.MsidbUpgradeAttributesVersionMinInclusive;
+                            }
+                            break;
+                        case "Language":
+                            language = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Minimum":
+                            minimum = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Maximum":
+                            maximum = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "UpgradeCode":
+                            upgradeCode = this.core.GetAttributeGuidValue(sourceLineNumbers, attrib, false);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == minimum && null == maximum)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttributes(sourceLineNumbers, node.Name.LocalName, "Minimum", "Maximum"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "Upgrade");
+                row[0] = upgradeCode;
+                row[1] = minimum;
+                row[2] = maximum;
+                row[3] = language;
+                row[4] = options;
+                row[6] = propertyId;
+            }
+        }
+
+        /// <summary>
+        /// Parses a registry search element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <returns>Signature for search element.</returns>
+        private string ParseRegistrySearchElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            bool explicitWin64 = false;
+            Identifier id = null;
+            string key = null;
+            string name = null;
+            string signature = null;
+            int root = CompilerConstants.IntegerNotSet;
+            int type = CompilerConstants.IntegerNotSet;
+            bool search64bit = false;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Key":
+                            key = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Name":
+                            name = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Root":
+                            root = this.core.GetAttributeMsidbRegistryRootValue(sourceLineNumbers, attrib, false);
+                            break;
+                        case "Type":
+                            string typeValue = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (0 < typeValue.Length)
+                            {
+                                Wix.RegistrySearch.TypeType typeType = Wix.RegistrySearch.ParseTypeType(typeValue);
+                                switch (typeType)
+                                {
+                                    case Wix.RegistrySearch.TypeType.directory:
+                                        type = 0;
+                                        break;
+                                    case Wix.RegistrySearch.TypeType.file:
+                                        type = 1;
+                                        break;
+                                    case Wix.RegistrySearch.TypeType.raw:
+                                        type = 2;
+                                        break;
+                                    default:
+                                        this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, "Type", typeValue, "directory", "file", "raw"));
+                                        break;
+                                }
+                            }
+                            break;
+                        case "Win64":
+                            explicitWin64 = true;
+                            search64bit = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (!explicitWin64 && (Platform.IA64 == this.CurrentPlatform || Platform.X64 == this.CurrentPlatform))
+            {
+                search64bit = true;
+            }
+
+            if (null == id)
+            {
+                id = this.core.CreateIdentifier("reg", root.ToString(), key, name, type.ToString(), search64bit.ToString());
+            }
+
+            if (null == key)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Key"));
+            }
+
+            if (CompilerConstants.IntegerNotSet == root)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Root"));
+            }
+
+            if (CompilerConstants.IntegerNotSet == type)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Type"));
+            }
+
+            signature = id.Id;
+            bool oneChild = false;
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "DirectorySearch":
+                            if (oneChild)
+                            {
+                                this.core.OnMessage(WixErrors.TooManySearchElements(sourceLineNumbers, node.Name.LocalName));
+                            }
+                            oneChild = true;
+
+                            // directorysearch parentage should work like directory element, not the rest of the signature type because of the DrLocator.Parent column
+                            signature = this.ParseDirectorySearchElement(child, id.Id);
+                            break;
+                        case "DirectorySearchRef":
+                            if (oneChild)
+                            {
+                                this.core.OnMessage(WixErrors.TooManySearchElements(sourceLineNumbers, node.Name.LocalName));
+                            }
+                            oneChild = true;
+                            signature = this.ParseDirectorySearchRefElement(child, id.Id);
+                            break;
+                        case "FileSearch":
+                            if (oneChild)
+                            {
+                                this.core.OnMessage(WixErrors.TooManySearchElements(sourceLineNumbers, node.Name.LocalName));
+                            }
+                            oneChild = true;
+                            signature = this.ParseFileSearchElement(child, id.Id, false, CompilerConstants.IntegerNotSet);
+                            id = new Identifier(signature, AccessModifier.Private); // FileSearch signatures override parent signatures
+                            break;
+                        case "FileSearchRef":
+                            if (oneChild)
+                            {
+                                this.core.OnMessage(WixErrors.TooManySearchElements(sourceLineNumbers, node.Name.LocalName));
+                            }
+                            oneChild = true;
+                            string newId = this.ParseSimpleRefElement(child, "Signature"); // FileSearch signatures override parent signatures
+                            id = new Identifier(newId, AccessModifier.Private);
+                            signature = null;
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "RegLocator", id);
+                row[1] = root;
+                row[2] = key;
+                row[3] = name;
+                row[4] = search64bit ? (type | 16) : type;
+            }
+
+            return signature;
+        }
+
+        /// <summary>
+        /// Parses a registry search reference element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <returns>Signature of referenced search element.</returns>
+        private string ParseRegistrySearchRefElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string id = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.core.CreateSimpleReference(sourceLineNumbers, "RegLocator", id);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            return id; // the id of the RegistrySearchRef element is its signature
+        }
+
+        /// <summary>
+        /// Parses child elements for search signatures.
+        /// </summary>
+        /// <param name="node">Node whose children we are parsing.</param>
+        /// <returns>Returns list of string signatures.</returns>
+        private List<string> ParseSearchSignatures(XElement node)
+        {
+            List<string> signatures = new List<string>();
+
+            foreach (XElement child in node.Elements())
+            {
+                string signature = null;
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "ComplianceDrive":
+                            signature = this.ParseComplianceDriveElement(child);
+                            break;
+                        case "ComponentSearch":
+                            signature = this.ParseComponentSearchElement(child);
+                            break;
+                        case "DirectorySearch":
+                            signature = this.ParseDirectorySearchElement(child, String.Empty);
+                            break;
+                        case "DirectorySearchRef":
+                            signature = this.ParseDirectorySearchRefElement(child, String.Empty);
+                            break;
+                        case "IniFileSearch":
+                            signature = this.ParseIniFileSearchElement(child);
+                            break;
+                        case "ProductSearch":
+                            // handled in ParsePropertyElement
+                            break;
+                        case "RegistrySearch":
+                            signature = this.ParseRegistrySearchElement(child);
+                            break;
+                        case "RegistrySearchRef":
+                            signature = this.ParseRegistrySearchRefElement(child);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+
+
+                if (!String.IsNullOrEmpty(signature))
+                {
+                    signatures.Add(signature);
+                }
+            }
+
+            return signatures;
+        }
+
+        /// <summary>
+        /// Parses a compliance drive element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <returns>Signature of nested search elements.</returns>
+        private string ParseComplianceDriveElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string signature = null;
+
+            bool oneChild = false;
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    SourceLineNumber childSourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+                    switch (child.Name.LocalName)
+                    {
+                        case "DirectorySearch":
+                            if (oneChild)
+                            {
+                                this.core.OnMessage(WixErrors.TooManySearchElements(childSourceLineNumbers, node.Name.LocalName));
+                            }
+                            oneChild = true;
+                            signature = this.ParseDirectorySearchElement(child, "CCP_DRIVE");
+                            break;
+                        case "DirectorySearchRef":
+                            if (oneChild)
+                            {
+                                this.core.OnMessage(WixErrors.TooManySearchElements(childSourceLineNumbers, node.Name.LocalName));
+                            }
+                            oneChild = true;
+                            signature = this.ParseDirectorySearchRefElement(child, "CCP_DRIVE");
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (null == signature)
+            {
+                this.core.OnMessage(WixErrors.SearchElementRequired(sourceLineNumbers, node.Name.LocalName));
+            }
+
+            return signature;
+        }
+
+        /// <summary>
+        /// Parses a compilance check element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        private void ParseComplianceCheckElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            string signature = null;
+
+            // see if this property is used for appSearch
+            List<string> signatures = this.ParseSearchSignatures(node);
+            foreach (string sig in signatures)
+            {
+                // if we haven't picked a signature for this ComplianceCheck pick
+                // this one
+                if (null == signature)
+                {
+                    signature = sig;
+                }
+                else if (signature != sig)
+                {
+                    // all signatures under a ComplianceCheck must be the same
+                    this.core.OnMessage(WixErrors.MultipleIdentifiersFound(sourceLineNumbers, node.Name.LocalName, sig, signature));
+                }
+            }
+
+            if (null == signature)
+            {
+                this.core.OnMessage(WixErrors.SearchElementRequired(sourceLineNumbers, node.Name.LocalName));
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "CCPSearch");
+                row[0] = signature;
+            }
+        }
+
+        /// <summary>
+        /// Parses a component element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="parentType">Type of component's complex reference parent.  Will be Uknown if there is no parent.</param>
+        /// <param name="parentId">Optional identifier for component's primary parent.</param>
+        /// <param name="parentLanguage">Optional string for component's parent's language.</param>
+        /// <param name="diskId">Optional disk id inherited from parent directory.</param>
+        /// <param name="directoryId">Optional identifier for component's directory.</param>
+        /// <param name="srcPath">Optional source path for files up to this point.</param>
+        [SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")]
+        private void ParseComponentElement(XElement node, ComplexReferenceParentType parentType, string parentId, string parentLanguage, int diskId, string directoryId, string srcPath)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+
+            int bits = 0;
+            int comPlusBits = CompilerConstants.IntegerNotSet;
+            string condition = null;
+            bool encounteredODBCDataSource = false;
+            bool explicitWin64 = false;
+            int files = 0;
+            string guid = "*";
+            string componentIdPlaceholder = String.Format(Compiler.DefaultComponentIdPlaceholderFormat, this.componentIdPlaceholdersResolver.VariableCount); // placeholder id for defaulting Component/@Id to keypath id.
+            string componentIdPlaceholderWixVariable = String.Format(Compiler.DefaultComponentIdPlaceholderWixVariableFormat, componentIdPlaceholder);
+            Identifier id = new Identifier(componentIdPlaceholderWixVariable, AccessModifier.Private);
+            int keyBits = 0;
+            bool keyFound = false;
+            string keyPath = null;
+            bool shouldAddCreateFolder = false;
+            bool win64 = false;
+            bool multiInstance = false;
+            List<string> symbols = new List<string>();
+            string feature = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "ComPlusFlags":
+                            comPlusBits = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, short.MaxValue);
+                            break;
+                        case "DisableRegistryReflection":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                bits |= MsiInterop.MsidbComponentAttributesDisableRegistryReflection;
+                            }
+                            break;
+                        case "Directory":
+                            directoryId = this.core.CreateDirectoryReferenceFromInlineSyntax(sourceLineNumbers, attrib, directoryId);
+                            break;
+                        case "DiskId":
+                            diskId = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 1, short.MaxValue);
+                            break;
+                        case "Feature":
+                            feature = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Guid":
+                            guid = this.core.GetAttributeGuidValue(sourceLineNumbers, attrib, true, true);
+                            break;
+                        case "KeyPath":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                keyFound = true;
+                                keyPath = null;
+                                keyBits = 0;
+                                shouldAddCreateFolder = true;
+                            }
+                            break;
+                        case "Location":
+                            string location = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (0 < location.Length)
+                            {
+                                Wix.Component.LocationType locationType = Wix.Component.ParseLocationType(location);
+                                switch (locationType)
+                                {
+                                    case Wix.Component.LocationType.either:
+                                        bits |= MsiInterop.MsidbComponentAttributesOptional;
+                                        break;
+                                    case Wix.Component.LocationType.local: // this is the default
+                                        break;
+                                    case Wix.Component.LocationType.source:
+                                        bits |= MsiInterop.MsidbComponentAttributesSourceOnly;
+                                        break;
+                                    default:
+                                        this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, "either", "local", "source"));
+                                        break;
+                                }
+                            }
+                            break;
+                        case "MultiInstance":
+                            multiInstance = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "NeverOverwrite":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                bits |= MsiInterop.MsidbComponentAttributesNeverOverwrite;
+                            }
+                            break;
+                        case "Permanent":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                bits |= MsiInterop.MsidbComponentAttributesPermanent;
+                            }
+                            break;
+                        case "Shared":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                bits |= MsiInterop.MsidbComponentAttributesShared;
+                            }
+                            break;
+                        case "SharedDllRefCount":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                bits |= MsiInterop.MsidbComponentAttributesSharedDllRefCount;
+                            }
+                            break;
+                        case "Transitive":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                bits |= MsiInterop.MsidbComponentAttributesTransitive;
+                            }
+                            break;
+                        case "UninstallWhenSuperseded":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                bits |= MsiInterop.MsidbComponentAttributesUninstallOnSupersedence;
+                            }
+                            break;
+                        case "Win64":
+                            explicitWin64 = true;
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                bits |= MsiInterop.MsidbComponentAttributes64bit;
+                                win64 = true;
+                            }
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (!explicitWin64 && (Platform.IA64 == this.CurrentPlatform || Platform.X64 == this.CurrentPlatform))
+            {
+                bits |= MsiInterop.MsidbComponentAttributes64bit;
+                win64 = true;
+            }
+
+            if (null == directoryId)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Directory"));
+            }
+
+            if (String.IsNullOrEmpty(guid) && MsiInterop.MsidbComponentAttributesShared == (bits & MsiInterop.MsidbComponentAttributesShared))
+            {
+                this.core.OnMessage(WixErrors.IllegalAttributeValueWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "Shared", "yes", "Guid", ""));
+            }
+
+            if (String.IsNullOrEmpty(guid) && MsiInterop.MsidbComponentAttributesPermanent == (bits & MsiInterop.MsidbComponentAttributesPermanent))
+            {
+                this.core.OnMessage(WixErrors.IllegalAttributeValueWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "Permanent", "yes", "Guid", ""));
+            }
+
+            if (null != feature)
+            {
+                if (this.compilingModule)
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeInMergeModule(sourceLineNumbers, node.Name.LocalName, "Feature"));
+                }
+                else
+                {
+                    if (ComplexReferenceParentType.Feature == parentType || ComplexReferenceParentType.FeatureGroup == parentType)
+                    {
+                        this.core.OnMessage(WixErrors.IllegalAttributeWhenNested(sourceLineNumbers, node.Name.LocalName, "Feature", node.Parent.Name.LocalName));
+                    }
+                    else
+                    {
+                        this.core.CreateComplexReference(sourceLineNumbers, ComplexReferenceParentType.Feature, feature, null, ComplexReferenceChildType.Component, id.Id, true);
+                    }
+                }
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                YesNoType keyPathSet = YesNoType.NotSet;
+                string keyPossible = null;
+                int keyBit = 0;
+
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "AppId":
+                            this.ParseAppIdElement(child, id.Id, YesNoType.NotSet, null, null, null);
+                            break;
+                        case "Category":
+                            this.ParseCategoryElement(child, id.Id);
+                            break;
+                        case "Class":
+                            this.ParseClassElement(child, id.Id, YesNoType.NotSet, null, null, null, null);
+                            break;
+                        case "Condition":
+                            if (null != condition)
+                            {
+                                SourceLineNumber childSourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+                                this.core.OnMessage(WixErrors.TooManyChildren(childSourceLineNumbers, node.Name.LocalName, child.Name.LocalName));
+                            }
+                            condition = this.ParseConditionElement(child, node.Name.LocalName, null, null);
+                            break;
+                        case "CopyFile":
+                            this.ParseCopyFileElement(child, id.Id, null);
+                            break;
+                        case "CreateFolder":
+                            string createdFolder = this.ParseCreateFolderElement(child, id.Id, directoryId, win64);
+                            if (directoryId == createdFolder)
+                            {
+                                shouldAddCreateFolder = false;
+                            }
+                            break;
+                        case "Environment":
+                            this.ParseEnvironmentElement(child, id.Id);
+                            break;
+                        case "Extension":
+                            this.ParseExtensionElement(child, id.Id, YesNoType.NotSet, null);
+                            break;
+                        case "File":
+                            keyPathSet = this.ParseFileElement(child, id.Id, directoryId, diskId, srcPath, out keyPossible, win64, guid);
+                            if (null != keyPossible)
+                            {
+                                keyBit = 0;
+                            }
+                            files++;
+                            break;
+                        case "IniFile":
+                            this.ParseIniFileElement(child, id.Id);
+                            break;
+                        case "Interface":
+                            this.ParseInterfaceElement(child, id.Id, null, null, null, null);
+                            break;
+                        case "IsolateComponent":
+                            this.ParseIsolateComponentElement(child, id.Id);
+                            break;
+                        case "ODBCDataSource":
+                            keyPathSet = this.ParseODBCDataSource(child, id.Id, null, out keyPossible);
+                            keyBit = MsiInterop.MsidbComponentAttributesODBCDataSource;
+                            encounteredODBCDataSource = true;
+                            break;
+                        case "ODBCDriver":
+                            this.ParseODBCDriverOrTranslator(child, id.Id, null, this.tableDefinitions["ODBCDriver"]);
+                            break;
+                        case "ODBCTranslator":
+                            this.ParseODBCDriverOrTranslator(child, id.Id, null, this.tableDefinitions["ODBCTranslator"]);
+                            break;
+                        case "ProgId":
+                            bool foundExtension = false;
+                            this.ParseProgIdElement(child, id.Id, YesNoType.NotSet, null, null, null, ref foundExtension, YesNoType.NotSet);
+                            break;
+                        case "RegistryKey":
+                            keyPathSet = this.ParseRegistryKeyElement(child, id.Id, CompilerConstants.IntegerNotSet, null, win64, out keyPossible);
+                            keyBit = MsiInterop.MsidbComponentAttributesRegistryKeyPath;
+                            break;
+                        case "RegistryValue":
+                            keyPathSet = this.ParseRegistryValueElement(child, id.Id, CompilerConstants.IntegerNotSet, null, win64, out keyPossible);
+                            keyBit = MsiInterop.MsidbComponentAttributesRegistryKeyPath;
+                            break;
+                        case "RemoveFile":
+                            this.ParseRemoveFileElement(child, id.Id, directoryId);
+                            break;
+                        case "RemoveFolder":
+                            this.ParseRemoveFolderElement(child, id.Id, directoryId);
+                            break;
+                        case "RemoveRegistryKey":
+                            this.ParseRemoveRegistryKeyElement(child, id.Id);
+                            break;
+                        case "RemoveRegistryValue":
+                            this.ParseRemoveRegistryValueElement(child, id.Id);
+                            break;
+                        case "ReserveCost":
+                            this.ParseReserveCostElement(child, id.Id, directoryId);
+                            break;
+                        case "ServiceConfig":
+                            this.ParseServiceConfigElement(child, id.Id, null);
+                            break;
+                        case "ServiceConfigFailureActions":
+                            this.ParseServiceConfigFailureActionsElement(child, id.Id, null);
+                            break;
+                        case "ServiceControl":
+                            this.ParseServiceControlElement(child, id.Id);
+                            break;
+                        case "ServiceInstall":
+                            this.ParseServiceInstallElement(child, id.Id, win64);
+                            break;
+                        case "Shortcut":
+                            this.ParseShortcutElement(child, id.Id, node.Name.LocalName, directoryId, YesNoType.No);
+                            break;
+                        case "SymbolPath":
+                            symbols.Add(this.ParseSymbolPathElement(child));
+                            break;
+                        case "TypeLib":
+                            this.ParseTypeLibElement(child, id.Id, null, win64);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    Dictionary<string, string> context = new Dictionary<string, string>() { { "ComponentId", id.Id }, { "DirectoryId", directoryId }, { "Win64", win64.ToString() }, };
+                    ComponentKeyPath possibleKeyPath = this.core.ParsePossibleKeyPathExtensionElement(node, child, context);
+                    if (null != possibleKeyPath)
+                    {
+                        if (ComponentKeyPathType.None == possibleKeyPath.Type)
+                        {
+                            keyPathSet = YesNoType.No;
+                        }
+                        else
+                        {
+                            keyPathSet = possibleKeyPath.Explicit ? YesNoType.Yes : YesNoType.NotSet;
+
+                            if (!String.IsNullOrEmpty(possibleKeyPath.Id))
+                            {
+                                keyPossible = possibleKeyPath.Id;
+                            }
+
+                            if (ComponentKeyPathType.Registry == possibleKeyPath.Type || ComponentKeyPathType.RegistryFormatted == possibleKeyPath.Type)
+                            {
+                                keyBit = MsiInterop.MsidbComponentAttributesRegistryKeyPath;
+                            }
+                        }
+                    }
+                }
+
+                // Verify that either the key path is not set, or it is set along with a key path ID.
+                Debug.Assert(YesNoType.Yes != keyPathSet || (YesNoType.Yes == keyPathSet && null != keyPossible));
+
+                if (keyFound && YesNoType.Yes == keyPathSet)
+                {
+                    this.core.OnMessage(WixErrors.ComponentMultipleKeyPaths(sourceLineNumbers, node.Name.LocalName, "KeyPath", "yes", "File", "RegistryValue", "ODBCDataSource"));
+                }
+
+                // if a possible KeyPath has been found and that value was explicitly set as
+                // the KeyPath of the component, set it now.  Alternatively, if a possible
+                // KeyPath has been found and no KeyPath has been previously set, use this
+                // value as the default KeyPath of the component
+                if (!String.IsNullOrEmpty(keyPossible) && (YesNoType.Yes == keyPathSet || (YesNoType.NotSet == keyPathSet && String.IsNullOrEmpty(keyPath) && !keyFound)))
+                {
+                    keyFound = YesNoType.Yes == keyPathSet;
+                    keyPath = keyPossible;
+                    keyBits = keyBit;
+                }
+            }
+
+
+            if (shouldAddCreateFolder)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "CreateFolder");
+                row[0] = directoryId;
+                row[1] = id.Id;
+            }
+
+            // check for conditions that exclude this component from using generated guids
+            bool isGeneratableGuidOk = "*" == guid;
+            if (isGeneratableGuidOk)
+            {
+                if (encounteredODBCDataSource)
+                {
+                    this.core.OnMessage(WixErrors.IllegalComponentWithAutoGeneratedGuid(sourceLineNumbers));
+                    isGeneratableGuidOk = false;
+                }
+
+                if (0 != files && MsiInterop.MsidbComponentAttributesRegistryKeyPath == keyBits)
+                {
+                    this.core.OnMessage(WixErrors.IllegalComponentWithAutoGeneratedGuid(sourceLineNumbers, true));
+                    isGeneratableGuidOk = false;
+                }
+            }
+
+            // check for implicit KeyPath which can easily be accidentally changed
+            if (this.showPedanticMessages && !keyFound && !isGeneratableGuidOk)
+            {
+                this.core.OnMessage(WixErrors.ImplicitComponentKeyPath(sourceLineNumbers, id.Id));
+            }
+
+            // if there isn't an @Id attribute value, replace the placeholder with the id of the keypath.
+            // either an explicit KeyPath="yes" attribute must be specified or requirements for 
+            // generatable guid must be met.
+            if (componentIdPlaceholderWixVariable == id.Id)
+            {
+                if (isGeneratableGuidOk || keyFound && !String.IsNullOrEmpty(keyPath))
+                {
+                    this.componentIdPlaceholdersResolver.AddVariable(componentIdPlaceholder, keyPath);
+
+                    id = new Identifier(keyPath, AccessModifier.Private);
+                }
+                else
+                {
+                    this.core.OnMessage(WixErrors.CannotDefaultComponentId(sourceLineNumbers));
+                }
+            }
+
+            // If an id was not determined by now, we have to error.
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            // finally add the Component table row
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "Component", id);
+                row[1] = guid;
+                row[2] = directoryId;
+                row[3] = bits | keyBits;
+                row[4] = condition;
+                row[5] = keyPath;
+
+                if (multiInstance)
+                {
+                    Row instanceComponentRow = this.core.CreateRow(sourceLineNumbers, "WixInstanceComponent");
+                    instanceComponentRow[0] = id;
+                }
+
+                if (0 < symbols.Count)
+                {
+                    WixDeltaPatchSymbolPathsRow symbolRow = (WixDeltaPatchSymbolPathsRow)this.core.CreateRow(sourceLineNumbers, "WixDeltaPatchSymbolPaths", id);
+                    symbolRow.Type = SymbolPathType.Component;
+                    symbolRow.SymbolPaths = String.Join(";", symbols);
+                }
+
+                // Complus
+                if (CompilerConstants.IntegerNotSet != comPlusBits)
+                {
+                    row = this.core.CreateRow(sourceLineNumbers, "Complus");
+                    row[0] = id;
+                    row[1] = comPlusBits;
+                }
+
+                // if this is a module, automatically add this component to the references to ensure it gets in the ModuleComponents table
+                if (this.compilingModule)
+                {
+                    this.core.CreateComplexReference(sourceLineNumbers, ComplexReferenceParentType.Module, this.activeName, this.activeLanguage, ComplexReferenceChildType.Component, id.Id, false);
+                }
+                else if (ComplexReferenceParentType.Unknown != parentType && null != parentId) // if parent was provided, add a complex reference to that.
+                {
+                    // If the Component is defined directly under a feature, then mark the complex reference primary.
+                    this.core.CreateComplexReference(sourceLineNumbers, parentType, parentId, parentLanguage, ComplexReferenceChildType.Component, id.Id, ComplexReferenceParentType.Feature == parentType);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses a component group element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        [SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")]
+        private void ParseComponentGroupElement(XElement node, ComplexReferenceParentType parentType, string parentId)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            string directoryId = null;
+            string source = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Directory":
+                            // If the inline syntax is invalid it returns null. Use a static error identifier so the null
+                            // directory identifier here doesn't trickle down false errors into child elements.
+                            directoryId = this.core.CreateDirectoryReferenceFromInlineSyntax(sourceLineNumbers, attrib, null) ?? "ErrorParsingInlineSyntax";
+                            break;
+                        case "Source":
+                            source = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+                id = Identifier.Invalid;
+            }
+
+            if (!String.IsNullOrEmpty(source) && !source.EndsWith(Path.DirectorySeparatorChar.ToString(), StringComparison.Ordinal))
+            {
+                source = String.Concat(source, Path.DirectorySeparatorChar);
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "ComponentGroupRef":
+                            this.ParseComponentGroupRefElement(child, ComplexReferenceParentType.ComponentGroup, id.Id, null);
+                            break;
+                        case "ComponentRef":
+                            this.ParseComponentRefElement(child, ComplexReferenceParentType.ComponentGroup, id.Id, null);
+                            break;
+                        case "Component":
+                            this.ParseComponentElement(child, ComplexReferenceParentType.ComponentGroup, id.Id, null, CompilerConstants.IntegerNotSet, directoryId, source);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "WixComponentGroup", id);
+
+                // Add this componentGroup and its parent in WixGroup.
+                this.core.CreateWixGroupRow(sourceLineNumbers, parentType, parentId, ComplexReferenceChildType.ComponentGroup, id.Id);
+            }
+        }
+
+        /// <summary>
+        /// Parses a component group reference element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="parentType">ComplexReferenceParentType of parent element.</param>
+        /// <param name="parentId">Identifier of parent element (usually a Feature or Module).</param>
+        /// <param name="parentLanguage">Optional language of parent (only useful for Modules).</param>
+        private void ParseComponentGroupRefElement(XElement node, ComplexReferenceParentType parentType, string parentId, string parentLanguage)
+        {
+            Debug.Assert(ComplexReferenceParentType.ComponentGroup == parentType || ComplexReferenceParentType.FeatureGroup == parentType || ComplexReferenceParentType.Feature == parentType || ComplexReferenceParentType.Module == parentType);
+
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string id = null;
+            YesNoType primary = YesNoType.NotSet;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.core.CreateSimpleReference(sourceLineNumbers, "WixComponentGroup", id);
+                            break;
+                        case "Primary":
+                            primary = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            this.core.CreateComplexReference(sourceLineNumbers, parentType, parentId, parentLanguage, ComplexReferenceChildType.ComponentGroup, id, (YesNoType.Yes == primary));
+        }
+
+        /// <summary>
+        /// Parses a component reference element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="parentType">ComplexReferenceParentType of parent element.</param>
+        /// <param name="parentId">Identifier of parent element (usually a Feature or Module).</param>
+        /// <param name="parentLanguage">Optional language of parent (only useful for Modules).</param>
+        private void ParseComponentRefElement(XElement node, ComplexReferenceParentType parentType, string parentId, string parentLanguage)
+        {
+            Debug.Assert(ComplexReferenceParentType.FeatureGroup == parentType || ComplexReferenceParentType.ComponentGroup == parentType || ComplexReferenceParentType.Feature == parentType || ComplexReferenceParentType.Module == parentType);
+
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string id = null;
+            YesNoType primary = YesNoType.NotSet;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.core.CreateSimpleReference(sourceLineNumbers, "Component", id);
+                            break;
+                        case "Primary":
+                            primary = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            this.core.CreateComplexReference(sourceLineNumbers, parentType, parentId, parentLanguage, ComplexReferenceChildType.Component, id, (YesNoType.Yes == primary));
+        }
+
+        /// <summary>
+        /// Parses a component search element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <returns>Signature for search element.</returns>
+        private string ParseComponentSearchElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            string componentId = null;
+            int type = MsiInterop.MsidbLocatorTypeFileName;
+            string signature = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Guid":
+                            componentId = this.core.GetAttributeGuidValue(sourceLineNumbers, attrib, false);
+                            break;
+                        case "Type":
+                            string typeValue = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (0 < typeValue.Length)
+                            {
+                                Wix.ComponentSearch.TypeType typeType = Wix.ComponentSearch.ParseTypeType(typeValue);
+                                switch (typeType)
+                                {
+                                    case Wix.ComponentSearch.TypeType.directory:
+                                        type = MsiInterop.MsidbLocatorTypeDirectory;
+                                        break;
+                                    case Wix.ComponentSearch.TypeType.file:
+                                        type = MsiInterop.MsidbLocatorTypeFileName;
+                                        break;
+                                    default:
+                                        this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, typeValue, "directory", "file"));
+                                        break;
+                                }
+                            }
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                id = this.core.CreateIdentifier("cmp", componentId, type.ToString());
+            }
+
+            signature = id.Id;
+            bool oneChild = false;
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "DirectorySearch":
+                            if (oneChild)
+                            {
+                                this.core.OnMessage(WixErrors.TooManySearchElements(sourceLineNumbers, node.Name.LocalName));
+                            }
+                            oneChild = true;
+
+                            // directorysearch parentage should work like directory element, not the rest of the signature type because of the DrLocator.Parent column
+                            signature = this.ParseDirectorySearchElement(child, id.Id);
+                            break;
+                        case "DirectorySearchRef":
+                            if (oneChild)
+                            {
+                                this.core.OnMessage(WixErrors.TooManySearchElements(sourceLineNumbers, node.Name.LocalName));
+                            }
+                            oneChild = true;
+                            signature = this.ParseDirectorySearchRefElement(child, id.Id);
+                            break;
+                        case "FileSearch":
+                            if (oneChild)
+                            {
+                                this.core.OnMessage(WixErrors.TooManySearchElements(sourceLineNumbers, node.Name.LocalName));
+                            }
+                            oneChild = true;
+                            signature = this.ParseFileSearchElement(child, id.Id, false, CompilerConstants.IntegerNotSet);
+                            id = new Identifier(signature, AccessModifier.Private); // FileSearch signatures override parent signatures
+                            break;
+                        case "FileSearchRef":
+                            if (oneChild)
+                            {
+                                this.core.OnMessage(WixErrors.TooManySearchElements(sourceLineNumbers, node.Name.LocalName));
+                            }
+                            oneChild = true;
+                            string newId = this.ParseSimpleRefElement(child, "Signature"); // FileSearch signatures override parent signatures
+                            id = new Identifier(newId, AccessModifier.Private);
+                            signature = null;
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "CompLocator", id);
+                row[1] = componentId;
+                row[2] = type;
+            }
+
+            return signature;
+        }
+
+        /// <summary>
+        /// Parses a create folder element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="componentId">Identifier for parent component.</param>
+        /// <param name="directoryId">Default identifier for directory to create.</param>
+        /// <param name="win64Component">true if the component is 64-bit.</param>
+        /// <returns>Identifier for the directory that will be created</returns>
+        private string ParseCreateFolderElement(XElement node, string componentId, string directoryId, bool win64Component)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Directory":
+                            directoryId = this.core.CreateDirectoryReferenceFromInlineSyntax(sourceLineNumbers, attrib, directoryId);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "Shortcut":
+                            this.ParseShortcutElement(child, componentId, node.Name.LocalName, directoryId, YesNoType.No);
+                            break;
+                        case "Permission":
+                            this.ParsePermissionElement(child, directoryId, "CreateFolder");
+                            break;
+                        case "PermissionEx":
+                            this.ParsePermissionExElement(child, directoryId, "CreateFolder");
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    Dictionary<string, string> context = new Dictionary<string, string>() { { "DirectoryId", directoryId }, { "ComponentId", componentId }, { "Win64", win64Component.ToString() } };
+                    this.core.ParseExtensionElement(node, child, context);
+                }
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "CreateFolder");
+                row[0] = directoryId;
+                row[1] = componentId;
+            }
+
+            return directoryId;
+        }
+
+        /// <summary>
+        /// Parses a copy file element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="componentId">Identifier of parent component.</param>
+        /// <param name="fileId">Identifier of file to copy (null if moving the file).</param>
+        private void ParseCopyFileElement(XElement node, string componentId, string fileId)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            bool delete = false;
+            string destinationDirectory = null;
+            string destinationName = null;
+            string destinationShortName = null;
+            string destinationProperty = null;
+            string sourceDirectory = null;
+            string sourceFolder = null;
+            string sourceName = null;
+            string sourceProperty = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Delete":
+                            delete = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "DestinationDirectory":
+                            destinationDirectory = this.core.CreateDirectoryReferenceFromInlineSyntax(sourceLineNumbers, attrib, null);
+                            break;
+                        case "DestinationName":
+                            destinationName = this.core.GetAttributeLongFilename(sourceLineNumbers, attrib, false);
+                            break;
+                        case "DestinationProperty":
+                            destinationProperty = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        case "DestinationShortName":
+                            destinationShortName = this.core.GetAttributeShortFilename(sourceLineNumbers, attrib, false);
+                            break;
+                        case "FileId":
+                            if (null != fileId)
+                            {
+                                this.core.OnMessage(WixErrors.IllegalAttributeWhenNested(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, node.Parent.Name.LocalName));
+                            }
+                            fileId = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.core.CreateSimpleReference(sourceLineNumbers, "File", fileId);
+                            break;
+                        case "SourceDirectory":
+                            sourceDirectory = this.core.CreateDirectoryReferenceFromInlineSyntax(sourceLineNumbers, attrib, null);
+                            break;
+                        case "SourceName":
+                            sourceName = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "SourceProperty":
+                            sourceProperty = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null != sourceFolder && null != sourceDirectory) // SourceFolder and SourceDirectory cannot coexist
+            {
+                this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "SourceFolder", "SourceDirectory"));
+            }
+
+            if (null != sourceFolder && null != sourceProperty) // SourceFolder and SourceProperty cannot coexist
+            {
+                this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "SourceFolder", "SourceProperty"));
+            }
+
+            if (null != sourceDirectory && null != sourceProperty) // SourceDirectory and SourceProperty cannot coexist
+            {
+                this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "SourceProperty", "SourceDirectory"));
+            }
+
+            if (null != destinationDirectory && null != destinationProperty) // DestinationDirectory and DestinationProperty cannot coexist
+            {
+                this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "DestinationProperty", "DestinationDirectory"));
+            }
+
+            // generate a short file name
+            if (null == destinationShortName && (null != destinationName && !this.core.IsValidShortFilename(destinationName, false)))
+            {
+                destinationShortName = this.core.CreateShortName(destinationName, true, false, node.Name.LocalName, componentId);
+            }
+
+            if (null == id)
+            {
+                id = this.core.CreateIdentifier("cf", sourceFolder, sourceDirectory, sourceProperty, destinationDirectory, destinationProperty, destinationName);
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (null == fileId)
+            {
+                // DestinationDirectory or DestinationProperty must be specified
+                if (null == destinationDirectory && null == destinationProperty)
+                {
+                    this.core.OnMessage(WixErrors.ExpectedAttributesWithoutOtherAttribute(sourceLineNumbers, node.Name.LocalName, "DestinationDirectory", "DestinationProperty", "FileId"));
+                }
+
+                if (!this.core.EncounteredError)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "MoveFile", id);
+                    row[1] = componentId;
+                    row[2] = sourceName;
+                    row[3] = String.IsNullOrEmpty(destinationShortName) && String.IsNullOrEmpty(destinationName) ? null : GetMsiFilenameValue(destinationShortName, destinationName);
+                    if (null != sourceDirectory)
+                    {
+                        row[4] = sourceDirectory;
+                    }
+                    else if (null != sourceProperty)
+                    {
+                        row[4] = sourceProperty;
+                    }
+                    else
+                    {
+                        row[4] = sourceFolder;
+                    }
+
+                    if (null != destinationDirectory)
+                    {
+                        row[5] = destinationDirectory;
+                    }
+                    else
+                    {
+                        row[5] = destinationProperty;
+                    }
+                    row[6] = delete ? 1 : 0;
+                }
+            }
+            else // copy the file
+            {
+                if (null != sourceDirectory)
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "SourceDirectory", "FileId"));
+                }
+
+                if (null != sourceFolder)
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "SourceFolder", "FileId"));
+                }
+
+                if (null != sourceName)
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "SourceName", "FileId"));
+                }
+
+                if (null != sourceProperty)
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "SourceProperty", "FileId"));
+                }
+
+                if (delete)
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "Delete", "FileId"));
+                }
+
+                if (null == destinationName && null == destinationDirectory && null == destinationProperty)
+                {
+                    this.core.OnMessage(WixWarnings.CopyFileFileIdUseless(sourceLineNumbers));
+                }
+
+                if (!this.core.EncounteredError)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "DuplicateFile", id);
+                    row[1] = componentId;
+                    row[2] = fileId;
+                    row[3] = String.IsNullOrEmpty(destinationShortName) && String.IsNullOrEmpty(destinationName) ? null : GetMsiFilenameValue(destinationShortName, destinationName);
+                    if (null != destinationDirectory)
+                    {
+                        row[4] = destinationDirectory;
+                    }
+                    else
+                    {
+                        row[4] = destinationProperty;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses a CustomAction element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        private void ParseCustomActionElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            int bits = 0;
+            int extendedBits = 0;
+            bool inlineScript = false;
+            string innerText = null;
+            string source = null;
+            int sourceBits = 0;
+            YesNoType suppressModularization = YesNoType.NotSet;
+            string target = null;
+            int targetBits = 0;
+            bool explicitWin64 = false;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "BinaryKey":
+                            if (null != source)
+                            {
+                                this.core.OnMessage(WixErrors.CustomActionMultipleSources(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, "BinaryKey", "Directory", "FileKey", "Property", "Script"));
+                            }
+                            source = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            sourceBits = MsiInterop.MsidbCustomActionTypeBinaryData;
+                            this.core.CreateSimpleReference(sourceLineNumbers, "Binary", source); // add a reference to the appropriate Binary
+                            break;
+                        case "Directory":
+                            if (null != source)
+                            {
+                                this.core.OnMessage(WixErrors.CustomActionMultipleSources(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, "BinaryKey", "Directory", "FileKey", "Property", "Script"));
+                            }
+                            source = this.core.CreateDirectoryReferenceFromInlineSyntax(sourceLineNumbers, attrib, null);
+                            sourceBits = MsiInterop.MsidbCustomActionTypeDirectory;
+                            break;
+                        case "DllEntry":
+                            if (null != target)
+                            {
+                                this.core.OnMessage(WixErrors.CustomActionMultipleTargets(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, "DllEntry", "Error", "ExeCommand", "JScriptCall", "Script", "Value", "VBScriptCall"));
+                            }
+                            target = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            targetBits = MsiInterop.MsidbCustomActionTypeDll;
+                            break;
+                        case "Error":
+                            if (null != target)
+                            {
+                                this.core.OnMessage(WixErrors.CustomActionMultipleTargets(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, "DllEntry", "Error", "ExeCommand", "JScriptCall", "Script", "Value", "VBScriptCall"));
+                            }
+                            target = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            targetBits = MsiInterop.MsidbCustomActionTypeTextData | MsiInterop.MsidbCustomActionTypeSourceFile;
+
+                            bool errorReference = true;
+
+                            try
+                            {
+                                // The target can be either a formatted error string or a literal 
+                                // error number. Try to convert to error number to determine whether
+                                // to add a reference. No need to look at the value.
+                                Convert.ToInt32(target, CultureInfo.InvariantCulture.NumberFormat);
+                            }
+                            catch (FormatException)
+                            {
+                                errorReference = false;
+                            }
+                            catch (OverflowException)
+                            {
+                                errorReference = false;
+                            }
+
+                            if (errorReference)
+                            {
+                                this.core.CreateSimpleReference(sourceLineNumbers, "Error", target);
+                            }
+                            break;
+                        case "ExeCommand":
+                            if (null != target)
+                            {
+                                this.core.OnMessage(WixErrors.CustomActionMultipleTargets(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, "DllEntry", "Error", "ExeCommand", "JScriptCall", "Script", "Value", "VBScriptCall"));
+                            }
+                            target = this.core.GetAttributeValue(sourceLineNumbers, attrib, EmptyRule.CanBeEmpty); // one of the few cases where an empty string value is valid
+                            targetBits = MsiInterop.MsidbCustomActionTypeExe;
+                            break;
+                        case "Execute":
+                            string execute = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (0 < execute.Length)
+                            {
+                                Wix.CustomAction.ExecuteType executeType = Wix.CustomAction.ParseExecuteType(execute);
+                                switch (executeType)
+                                {
+                                    case Wix.CustomAction.ExecuteType.commit:
+                                        bits |= MsiInterop.MsidbCustomActionTypeInScript | MsiInterop.MsidbCustomActionTypeCommit;
+                                        break;
+                                    case Wix.CustomAction.ExecuteType.deferred:
+                                        bits |= MsiInterop.MsidbCustomActionTypeInScript;
+                                        break;
+                                    case Wix.CustomAction.ExecuteType.firstSequence:
+                                        bits |= MsiInterop.MsidbCustomActionTypeFirstSequence;
+                                        break;
+                                    case Wix.CustomAction.ExecuteType.immediate:
+                                        break;
+                                    case Wix.CustomAction.ExecuteType.oncePerProcess:
+                                        bits |= MsiInterop.MsidbCustomActionTypeOncePerProcess;
+                                        break;
+                                    case Wix.CustomAction.ExecuteType.rollback:
+                                        bits |= MsiInterop.MsidbCustomActionTypeInScript | MsiInterop.MsidbCustomActionTypeRollback;
+                                        break;
+                                    case Wix.CustomAction.ExecuteType.secondSequence:
+                                        bits |= MsiInterop.MsidbCustomActionTypeClientRepeat;
+                                        break;
+                                    default:
+                                        this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, execute, "commit", "deferred", "firstSequence", "immediate", "oncePerProcess", "rollback", "secondSequence"));
+                                        break;
+                                }
+                            }
+                            break;
+                        case "FileKey":
+                            if (null != source)
+                            {
+                                this.core.OnMessage(WixErrors.CustomActionMultipleSources(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, "BinaryKey", "Directory", "FileKey", "Property", "Script"));
+                            }
+                            source = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            sourceBits = MsiInterop.MsidbCustomActionTypeSourceFile;
+                            this.core.CreateSimpleReference(sourceLineNumbers, "File", source); // add a reference to the appropriate File
+                            break;
+                        case "HideTarget":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                bits |= MsiInterop.MsidbCustomActionTypeHideTarget;
+                            }
+                            break;
+                        case "Impersonate":
+                            if (YesNoType.No == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                bits |= MsiInterop.MsidbCustomActionTypeNoImpersonate;
+                            }
+                            break;
+                        case "JScriptCall":
+                            if (null != target)
+                            {
+                                this.core.OnMessage(WixErrors.CustomActionMultipleTargets(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, "DllEntry", "Error", "ExeCommand", "JScriptCall", "Script", "Value", "VBScriptCall"));
+                            }
+                            target = this.core.GetAttributeValue(sourceLineNumbers, attrib, EmptyRule.CanBeEmpty); // one of the few cases where an empty string value is valid
+                            targetBits = MsiInterop.MsidbCustomActionTypeJScript;
+                            break;
+                        case "PatchUninstall":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                extendedBits |= MsiInterop.MsidbCustomActionTypePatchUninstall;
+                            }
+                            break;
+                        case "Property":
+                            if (null != source)
+                            {
+                                this.core.OnMessage(WixErrors.CustomActionMultipleSources(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, "BinaryKey", "Directory", "FileKey", "Property", "Script"));
+                            }
+                            source = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            sourceBits = MsiInterop.MsidbCustomActionTypeProperty;
+                            break;
+                        case "Return":
+                            string returnValue = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (0 < returnValue.Length)
+                            {
+                                Wix.CustomAction.ReturnType returnType = Wix.CustomAction.ParseReturnType(returnValue);
+                                switch (returnType)
+                                {
+                                    case Wix.CustomAction.ReturnType.asyncNoWait:
+                                        bits |= MsiInterop.MsidbCustomActionTypeAsync | MsiInterop.MsidbCustomActionTypeContinue;
+                                        break;
+                                    case Wix.CustomAction.ReturnType.asyncWait:
+                                        bits |= MsiInterop.MsidbCustomActionTypeAsync;
+                                        break;
+                                    case Wix.CustomAction.ReturnType.check:
+                                        break;
+                                    case Wix.CustomAction.ReturnType.ignore:
+                                        bits |= MsiInterop.MsidbCustomActionTypeContinue;
+                                        break;
+                                    default:
+                                        this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, returnValue, "asyncNoWait", "asyncWait", "check", "ignore"));
+                                        break;
+                                }
+                            }
+                            break;
+                        case "Script":
+                            if (null != source)
+                            {
+                                this.core.OnMessage(WixErrors.CustomActionMultipleSources(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, "BinaryKey", "Directory", "FileKey", "Property", "Script"));
+                            }
+
+                            if (null != target)
+                            {
+                                this.core.OnMessage(WixErrors.CustomActionMultipleTargets(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, "DllEntry", "Error", "ExeCommand", "JScriptCall", "Script", "Value", "VBScriptCall"));
+                            }
+
+                            // set the source and target to empty string for error messages when the user sets multiple sources or targets
+                            source = string.Empty;
+                            target = string.Empty;
+
+                            inlineScript = true;
+
+                            string script = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (0 < script.Length)
+                            {
+                                Wix.CustomAction.ScriptType scriptType = Wix.CustomAction.ParseScriptType(script);
+                                switch (scriptType)
+                                {
+                                    case Wix.CustomAction.ScriptType.jscript:
+                                        sourceBits = MsiInterop.MsidbCustomActionTypeDirectory;
+                                        targetBits = MsiInterop.MsidbCustomActionTypeJScript;
+                                        break;
+                                    case Wix.CustomAction.ScriptType.vbscript:
+                                        sourceBits = MsiInterop.MsidbCustomActionTypeDirectory;
+                                        targetBits = MsiInterop.MsidbCustomActionTypeVBScript;
+                                        break;
+                                    default:
+                                        this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, script, "jscript", "vbscript"));
+                                        break;
+                                }
+                            }
+                            break;
+                        case "SuppressModularization":
+                            suppressModularization = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "TerminalServerAware":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                bits |= MsiInterop.MsidbCustomActionTypeTSAware;
+                            }
+                            break;
+                        case "Value":
+                            if (null != target)
+                            {
+                                this.core.OnMessage(WixErrors.CustomActionMultipleTargets(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, "DllEntry", "Error", "ExeCommand", "JScriptCall", "Script", "Value", "VBScriptCall"));
+                            }
+                            target = this.core.GetAttributeValue(sourceLineNumbers, attrib, EmptyRule.CanBeEmpty); // one of the few cases where an empty string value is valid
+                            targetBits = MsiInterop.MsidbCustomActionTypeTextData;
+                            break;
+                        case "VBScriptCall":
+                            if (null != target)
+                            {
+                                this.core.OnMessage(WixErrors.CustomActionMultipleTargets(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, "DllEntry", "Error", "ExeCommand", "JScriptCall", "Script", "Value", "VBScriptCall"));
+                            }
+                            target = this.core.GetAttributeValue(sourceLineNumbers, attrib, EmptyRule.CanBeEmpty); // one of the few cases where an empty string value is valid
+                            targetBits = MsiInterop.MsidbCustomActionTypeVBScript;
+                            break;
+                        case "Win64":
+                            explicitWin64 = true;
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                bits |= MsiInterop.MsidbCustomActionType64BitScript;
+                            }
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+                id = Identifier.Invalid;
+            }
+
+            if (!explicitWin64 && (MsiInterop.MsidbCustomActionTypeVBScript == targetBits || MsiInterop.MsidbCustomActionTypeJScript == targetBits) && (Platform.IA64 == this.CurrentPlatform || Platform.X64 == this.CurrentPlatform))
+            {
+                bits |= MsiInterop.MsidbCustomActionType64BitScript;
+            }
+
+            // get the inner text if any exists
+            innerText = this.core.GetTrimmedInnerText(node);
+
+            // if we have an in-lined Script CustomAction ensure no source or target attributes were provided
+            if (inlineScript)
+            {
+                target = innerText;
+            }
+            else if (MsiInterop.MsidbCustomActionTypeVBScript == targetBits) // non-inline vbscript
+            {
+                if (null == source)
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeWithoutOtherAttributes(sourceLineNumbers, node.Name.LocalName, "VBScriptCall", "BinaryKey", "FileKey", "Property"));
+                }
+                else if (MsiInterop.MsidbCustomActionTypeDirectory == sourceBits)
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "VBScriptCall", "Directory"));
+                }
+            }
+            else if (MsiInterop.MsidbCustomActionTypeJScript == targetBits) // non-inline jscript
+            {
+                if (null == source)
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeWithoutOtherAttributes(sourceLineNumbers, node.Name.LocalName, "JScriptCall", "BinaryKey", "FileKey", "Property"));
+                }
+                else if (MsiInterop.MsidbCustomActionTypeDirectory == sourceBits)
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "JScriptCall", "Directory"));
+                }
+            }
+            else if (MsiInterop.MsidbCustomActionTypeExe == targetBits) // exe-command
+            {
+                if (null == source)
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeWithoutOtherAttributes(sourceLineNumbers, node.Name.LocalName, "ExeCommand", "BinaryKey", "Directory", "FileKey", "Property"));
+                }
+            }
+            else if (MsiInterop.MsidbCustomActionTypeTextData == (bits | sourceBits | targetBits))
+            {
+                this.core.OnMessage(WixErrors.IllegalAttributeWithoutOtherAttributes(sourceLineNumbers, node.Name.LocalName, "Value", "Directory", "Property"));
+            }
+            else if (!String.IsNullOrEmpty(innerText)) // inner text cannot be specified with non-script CAs
+            {
+                this.core.OnMessage(WixErrors.CustomActionIllegalInnerText(sourceLineNumbers, node.Name.LocalName, innerText, "Script"));
+            }
+
+            if (MsiInterop.MsidbCustomActionType64BitScript == (bits & MsiInterop.MsidbCustomActionType64BitScript) && MsiInterop.MsidbCustomActionTypeVBScript != targetBits && MsiInterop.MsidbCustomActionTypeJScript != targetBits)
+            {
+                this.core.OnMessage(WixErrors.IllegalAttributeWithoutOtherAttributes(sourceLineNumbers, node.Name.LocalName, "Win64", "Script", "VBScriptCall", "JScriptCall"));
+            }
+
+            if ((MsiInterop.MsidbCustomActionTypeAsync | MsiInterop.MsidbCustomActionTypeContinue) == (bits & (MsiInterop.MsidbCustomActionTypeAsync | MsiInterop.MsidbCustomActionTypeContinue)) && MsiInterop.MsidbCustomActionTypeExe != targetBits)
+            {
+                this.core.OnMessage(WixErrors.IllegalAttributeValueWithoutOtherAttribute(sourceLineNumbers, node.Name.LocalName, "Return", "asyncNoWait", "ExeCommand"));
+            }
+
+            if (MsiInterop.MsidbCustomActionTypeTSAware == (bits & MsiInterop.MsidbCustomActionTypeTSAware))
+            {
+                // TS-aware CAs are valid only when deferred so require the in-script Type bit...
+                if (0 == (bits & MsiInterop.MsidbCustomActionTypeInScript))
+                {
+                    this.core.OnMessage(WixErrors.IllegalTerminalServerCustomActionAttributes(sourceLineNumbers));
+                }
+            }
+
+            // MSI doesn't support in-script property setting, so disallow it
+            if (MsiInterop.MsidbCustomActionTypeProperty == sourceBits &&
+                MsiInterop.MsidbCustomActionTypeTextData == targetBits &&
+                0 != (bits & MsiInterop.MsidbCustomActionTypeInScript))
+            {
+                this.core.OnMessage(WixErrors.IllegalPropertyCustomActionAttributes(sourceLineNumbers));
+            }
+
+            if (0 == targetBits)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttributes(sourceLineNumbers, node.Name.LocalName, "DllEntry", "Error", "ExeCommand", "JScriptCall", "Script", "Value", "VBScriptCall"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "CustomAction", id);
+                row[1] = bits | sourceBits | targetBits;
+                row[2] = source;
+                row[3] = target;
+                if (0 != extendedBits)
+                {
+                    row[4] = extendedBits;
+                }
+
+                if (YesNoType.Yes == suppressModularization)
+                {
+                    this.core.CreateRow(sourceLineNumbers, "WixSuppressModularization", id);
+                }
+
+                // For deferred CAs that specify HideTarget we should also hide the CA data property for the action.
+                if (MsiInterop.MsidbCustomActionTypeHideTarget == (bits & MsiInterop.MsidbCustomActionTypeHideTarget) &&
+                    MsiInterop.MsidbCustomActionTypeInScript == (bits & MsiInterop.MsidbCustomActionTypeInScript))
+                {
+                    this.AddWixPropertyRow(sourceLineNumbers, id, false, false, true);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses a simple reference element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="table">Table which contains the target of the simple reference.</param>
+        /// <returns>Id of the referenced element.</returns>
+        private string ParseSimpleRefElement(XElement node, string table)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string id = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.core.CreateSimpleReference(sourceLineNumbers, table, id);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            return id;
+        }
+
+        /// <summary>
+        /// Parses a PatchFamilyRef element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="parentType">The parent type.</param>
+        /// <param name="parentId">The ID of the parent.</param>
+        /// <returns>Id of the referenced element.</returns>
+        private void ParsePatchFamilyRefElement(XElement node, ComplexReferenceParentType parentType, string parentId)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string[] primaryKeys = new string[2];
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            primaryKeys[0] = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ProductCode":
+                            primaryKeys[1] = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == primaryKeys[0])
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            this.core.CreateSimpleReference(sourceLineNumbers, "MsiPatchSequence", primaryKeys);
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                this.core.CreateComplexReference(sourceLineNumbers, parentType, parentId, null, ComplexReferenceChildType.PatchFamily, primaryKeys[0], true);
+            }
+        }
+
+        /// <summary>
+        /// Parses a PatchFamilyGroup element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")]
+        private void ParsePatchFamilyGroupElement(XElement node, ComplexReferenceParentType parentType, string parentId)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+                id = Identifier.Invalid;
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "PatchFamily":
+                            this.ParsePatchFamilyElement(child, ComplexReferenceParentType.PatchFamilyGroup, id.Id);
+                            break;
+                        case "PatchFamilyRef":
+                            this.ParsePatchFamilyRefElement(child, ComplexReferenceParentType.PatchFamilyGroup, id.Id);
+                            break;
+                        case "PatchFamilyGroupRef":
+                            this.ParsePatchFamilyGroupRefElement(child, ComplexReferenceParentType.PatchFamilyGroup, id.Id);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "WixPatchFamilyGroup", id);
+
+                //Add this PatchFamilyGroup and its parent in WixGroup.
+                this.core.CreateWixGroupRow(sourceLineNumbers, parentType, parentId, ComplexReferenceChildType.PatchFamilyGroup, id.Id);
+            }
+        }
+
+        /// <summary>
+        /// Parses a PatchFamilyGroup reference element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="parentType">The type of parent.</param>
+        /// <param name="parentId">Identifier of parent element.</param>
+        private void ParsePatchFamilyGroupRefElement(XElement node, ComplexReferenceParentType parentType, string parentId)
+        {
+            Debug.Assert(ComplexReferenceParentType.PatchFamilyGroup == parentType || ComplexReferenceParentType.Patch == parentType);
+
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string id = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.core.CreateSimpleReference(sourceLineNumbers, "WixPatchFamilyGroup", id);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                this.core.CreateComplexReference(sourceLineNumbers, parentType, parentId, null, ComplexReferenceChildType.PatchFamilyGroup, id, true);
+            }
+        }
+
+        /// <summary>
+        /// Parses an ensure table element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        private void ParseEnsureTableElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string id = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+            else if (31 < id.Length)
+            {
+                this.core.OnMessage(WixErrors.TableNameTooLong(sourceLineNumbers, node.Name.LocalName, "Id", id));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            this.core.EnsureTable(sourceLineNumbers, id);
+        }
+
+        /// <summary>
+        /// Parses a custom table element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <remarks>not cleaned</remarks>
+        [SuppressMessage("Microsoft.Globalization", "CA1308:NormalizeStringsToUppercase", Justification = "Changing the way this string normalizes would result " +
+                         "in a change to the way the WixCustomTable table is generated. Furthermore, there is no security hole here, as the strings won't need to " +
+                         "make a round trip")]
+        private void ParseCustomTableElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string tableId = null;
+
+            string categories = null;
+            int columnCount = 0;
+            string columnNames = null;
+            string columnTypes = null;
+            string descriptions = null;
+            string keyColumns = null;
+            string keyTables = null;
+            string maxValues = null;
+            string minValues = null;
+            string modularizations = null;
+            string primaryKeys = null;
+            string sets = null;
+            bool bootstrapperApplicationData = false;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            tableId = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        case "BootstrapperApplicationData":
+                            bootstrapperApplicationData = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == tableId)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+            else if (31 < tableId.Length)
+            {
+                this.core.OnMessage(WixErrors.CustomTableNameTooLong(sourceLineNumbers, node.Name.LocalName, "Id", tableId));
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    SourceLineNumber childSourceLineNumbers = Preprocessor.GetSourceLineNumbers(child);
+                    switch (child.Name.LocalName)
+                    {
+                        case "Column":
+                            ++columnCount;
+
+                            string category = String.Empty;
+                            string columnName = null;
+                            string columnType = null;
+                            string description = String.Empty;
+                            int keyColumn = CompilerConstants.IntegerNotSet;
+                            string keyTable = String.Empty;
+                            bool localizable = false;
+                            long maxValue = CompilerConstants.LongNotSet;
+                            long minValue = CompilerConstants.LongNotSet;
+                            string modularization = "None";
+                            bool nullable = false;
+                            bool primaryKey = false;
+                            string setValues = String.Empty;
+                            string typeName = null;
+                            int width = 0;
+
+                            foreach (XAttribute childAttrib in child.Attributes())
+                            {
+                                switch (childAttrib.Name.LocalName)
+                                {
+                                    case "Id":
+                                        columnName = this.core.GetAttributeIdentifierValue(childSourceLineNumbers, childAttrib);
+                                        break;
+                                    case "Category":
+                                        category = this.core.GetAttributeValue(childSourceLineNumbers, childAttrib);
+                                        break;
+                                    case "Description":
+                                        description = this.core.GetAttributeValue(childSourceLineNumbers, childAttrib);
+                                        break;
+                                    case "KeyColumn":
+                                        keyColumn = this.core.GetAttributeIntegerValue(childSourceLineNumbers, childAttrib, 1, 32);
+                                        break;
+                                    case "KeyTable":
+                                        keyTable = this.core.GetAttributeValue(childSourceLineNumbers, childAttrib);
+                                        break;
+                                    case "Localizable":
+                                        localizable = YesNoType.Yes == this.core.GetAttributeYesNoValue(childSourceLineNumbers, childAttrib);
+                                        break;
+                                    case "MaxValue":
+                                        maxValue = this.core.GetAttributeLongValue(childSourceLineNumbers, childAttrib, int.MinValue + 1, int.MaxValue);
+                                        break;
+                                    case "MinValue":
+                                        minValue = this.core.GetAttributeLongValue(childSourceLineNumbers, childAttrib, int.MinValue + 1, int.MaxValue);
+                                        break;
+                                    case "Modularize":
+                                        modularization = this.core.GetAttributeValue(childSourceLineNumbers, childAttrib);
+                                        break;
+                                    case "Nullable":
+                                        nullable = YesNoType.Yes == this.core.GetAttributeYesNoValue(childSourceLineNumbers, childAttrib);
+                                        break;
+                                    case "PrimaryKey":
+                                        primaryKey = YesNoType.Yes == this.core.GetAttributeYesNoValue(childSourceLineNumbers, childAttrib);
+                                        break;
+                                    case "Set":
+                                        setValues = this.core.GetAttributeValue(childSourceLineNumbers, childAttrib);
+                                        break;
+                                    case "Type":
+                                        string typeValue = this.core.GetAttributeValue(childSourceLineNumbers, childAttrib);
+                                        if (0 < typeValue.Length)
+                                        {
+                                            Wix.Column.TypeType typeType = Wix.Column.ParseTypeType(typeValue);
+                                            switch (typeType)
+                                            {
+                                                case Wix.Column.TypeType.binary:
+                                                    typeName = "OBJECT";
+                                                    break;
+                                                case Wix.Column.TypeType.@int:
+                                                    typeName = "SHORT";
+                                                    break;
+                                                case Wix.Column.TypeType.@string:
+                                                    typeName = "CHAR";
+                                                    break;
+                                                default:
+                                                    this.core.OnMessage(WixErrors.IllegalAttributeValue(childSourceLineNumbers, child.Name.LocalName, "Type", typeValue, "binary", "int", "string"));
+                                                    break;
+                                            }
+                                        }
+                                        break;
+                                    case "Width":
+                                        width = this.core.GetAttributeIntegerValue(childSourceLineNumbers, childAttrib, 0, int.MaxValue);
+                                        break;
+                                    default:
+                                        this.core.UnexpectedAttribute(child, childAttrib);
+                                        break;
+                                }
+                            }
+
+                            if (null == columnName)
+                            {
+                                this.core.OnMessage(WixErrors.ExpectedAttribute(childSourceLineNumbers, child.Name.LocalName, "Id"));
+                            }
+
+                            if (null == typeName)
+                            {
+                                this.core.OnMessage(WixErrors.ExpectedAttribute(childSourceLineNumbers, child.Name.LocalName, "Type"));
+                            }
+                            else if ("SHORT" == typeName)
+                            {
+                                if (2 != width && 4 != width)
+                                {
+                                    this.core.OnMessage(WixErrors.CustomTableIllegalColumnWidth(childSourceLineNumbers, child.Name.LocalName, "Width", width));
+                                }
+                                columnType = String.Concat(nullable ? "I" : "i", width);
+                            }
+                            else if ("CHAR" == typeName)
+                            {
+                                string typeChar = localizable ? "l" : "s";
+                                columnType = String.Concat(nullable ? typeChar.ToUpper(CultureInfo.InvariantCulture) : typeChar.ToLower(CultureInfo.InvariantCulture), width);
+                            }
+                            else if ("OBJECT" == typeName)
+                            {
+                                if ("Binary" != category)
+                                {
+                                    this.core.OnMessage(WixErrors.ExpectedBinaryCategory(childSourceLineNumbers));
+                                }
+                                columnType = String.Concat(nullable ? "V" : "v", width);
+                            }
+
+                            this.core.ParseForExtensionElements(child);
+
+                            columnNames = String.Concat(columnNames, null == columnNames ? String.Empty : "\t", columnName);
+                            columnTypes = String.Concat(columnTypes, null == columnTypes ? String.Empty : "\t", columnType);
+                            if (primaryKey)
+                            {
+                                primaryKeys = String.Concat(primaryKeys, null == primaryKeys ? String.Empty : "\t", columnName);
+                            }
+
+                            minValues = String.Concat(minValues, null == minValues ? String.Empty : "\t", CompilerConstants.LongNotSet != minValue ? minValue.ToString(CultureInfo.InvariantCulture) : String.Empty);
+                            maxValues = String.Concat(maxValues, null == maxValues ? String.Empty : "\t", CompilerConstants.LongNotSet != maxValue ? maxValue.ToString(CultureInfo.InvariantCulture) : String.Empty);
+                            keyTables = String.Concat(keyTables, null == keyTables ? String.Empty : "\t", keyTable);
+                            keyColumns = String.Concat(keyColumns, null == keyColumns ? String.Empty : "\t", CompilerConstants.IntegerNotSet != keyColumn ? keyColumn.ToString(CultureInfo.InvariantCulture) : String.Empty);
+                            categories = String.Concat(categories, null == categories ? String.Empty : "\t", category);
+                            sets = String.Concat(sets, null == sets ? String.Empty : "\t", setValues);
+                            descriptions = String.Concat(descriptions, null == descriptions ? String.Empty : "\t", description);
+                            modularizations = String.Concat(modularizations, null == modularizations ? String.Empty : "\t", modularization);
+
+                            break;
+                        case "Row":
+                            string dataValue = null;
+
+                            foreach (XAttribute childAttrib in child.Attributes())
+                            {
+                                this.core.ParseExtensionAttribute(child, childAttrib);
+                            }
+
+                            foreach (XElement data in child.Elements())
+                            {
+                                SourceLineNumber dataSourceLineNumbers = Preprocessor.GetSourceLineNumbers(data);
+                                switch (data.Name.LocalName)
+                                {
+                                    case "Data":
+                                        columnName = null;
+                                        foreach (XAttribute dataAttrib in data.Attributes())
+                                        {
+                                            switch (dataAttrib.Name.LocalName)
+                                            {
+                                                case "Column":
+                                                    columnName = this.core.GetAttributeValue(dataSourceLineNumbers, dataAttrib);
+                                                    break;
+                                                default:
+                                                    this.core.UnexpectedAttribute(data, dataAttrib);
+                                                    break;
+                                            }
+                                        }
+
+                                        if (null == columnName)
+                                        {
+                                            this.core.OnMessage(WixErrors.ExpectedAttribute(dataSourceLineNumbers, data.Name.LocalName, "Column"));
+                                        }
+
+                                        dataValue = String.Concat(dataValue, null == dataValue ? String.Empty : Common.CustomRowFieldSeparator.ToString(), columnName, ":", Common.GetInnerText(data));
+                                        break;
+                                }
+                            }
+
+                            this.core.CreateSimpleReference(sourceLineNumbers, "WixCustomTable", tableId);
+
+                            if (!this.core.EncounteredError)
+                            {
+                                Row rowRow = this.core.CreateRow(childSourceLineNumbers, "WixCustomRow");
+                                rowRow[0] = tableId;
+                                rowRow[1] = dataValue;
+                            }
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (0 < columnCount)
+            {
+                if (null == primaryKeys || 0 == primaryKeys.Length)
+                {
+                    this.core.OnMessage(WixErrors.CustomTableMissingPrimaryKey(sourceLineNumbers));
+                }
+
+                if (!this.core.EncounteredError)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "WixCustomTable");
+                    row[0] = tableId;
+                    row[1] = columnCount;
+                    row[2] = columnNames;
+                    row[3] = columnTypes;
+                    row[4] = primaryKeys;
+                    row[5] = minValues;
+                    row[6] = maxValues;
+                    row[7] = keyTables;
+                    row[8] = keyColumns;
+                    row[9] = categories;
+                    row[10] = sets;
+                    row[11] = descriptions;
+                    row[12] = modularizations;
+                    row[13] = bootstrapperApplicationData ? 1 : 0;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses a directory element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="parentId">Optional identifier of parent directory.</param>
+        /// <param name="diskId">Disk id inherited from parent directory.</param>
+        /// <param name="fileSource">Path to source file as of yet.</param>
+        [SuppressMessage("Microsoft.Performance", "CA1820:TestForEmptyStringsUsingStringLength")]
+        private void ParseDirectoryElement(XElement node, string parentId, int diskId, string fileSource)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            string componentGuidGenerationSeed = null;
+            bool fileSourceAttribSet = false;
+            bool nameHasValue = false;
+            string name = "."; // default to parent directory.
+            string[] inlineSyntax = null;
+            string shortName = null;
+            string sourceName = null;
+            string shortSourceName = null;
+            string defaultDir = null;
+            string symbols = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "ComponentGuidGenerationSeed":
+                            componentGuidGenerationSeed = this.core.GetAttributeGuidValue(sourceLineNumbers, attrib, false);
+                            break;
+                        case "DiskId":
+                            diskId = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 1, short.MaxValue);
+                            break;
+                        case "FileSource":
+                            fileSource = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            fileSourceAttribSet = true;
+                            break;
+                        case "Name":
+                            nameHasValue = true;
+                            if (attrib.Value.Equals("."))
+                            {
+                                name = attrib.Value;
+                            }
+                            else
+                            {
+                                inlineSyntax = this.core.GetAttributeInlineDirectorySyntax(sourceLineNumbers, attrib);
+                            }
+                            break;
+                        case "ShortName":
+                            shortName = this.core.GetAttributeShortFilename(sourceLineNumbers, attrib, false);
+                            break;
+                        case "ShortSourceName":
+                            shortSourceName = this.core.GetAttributeShortFilename(sourceLineNumbers, attrib, false);
+                            break;
+                        case "SourceName":
+                            if ("." == attrib.Value)
+                            {
+                                sourceName = attrib.Value;
+                            }
+                            else
+                            {
+                                sourceName = this.core.GetAttributeLongFilename(sourceLineNumbers, attrib, false);
+                            }
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            // Create the directory rows for the inline.
+            if (null != inlineSyntax)
+            {
+                // Special case the single entry in the inline syntax since it is the most common case
+                // and needs no extra processing. It's just the name of the directory.
+                if (1 == inlineSyntax.Length)
+                {
+                    name = inlineSyntax[0];
+                }
+                else
+                {
+                    int pathStartsAt = 0;
+                    if (inlineSyntax[0].EndsWith(":"))
+                    {
+                        parentId = inlineSyntax[0].TrimEnd(':');
+                        this.core.CreateSimpleReference(sourceLineNumbers, "Directory", parentId);
+
+                        pathStartsAt = 1;
+                    }
+
+                    for (int i = pathStartsAt; i < inlineSyntax.Length - 1; ++i)
+                    {
+                        Identifier inlineId = this.core.CreateDirectoryRow(sourceLineNumbers, null, parentId, inlineSyntax[i]);
+                        parentId = inlineId.Id;
+                    }
+
+                    name = inlineSyntax[inlineSyntax.Length - 1];
+                }
+            }
+
+            if (!nameHasValue)
+            {
+                if (!String.IsNullOrEmpty(shortName))
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeWithoutOtherAttributes(sourceLineNumbers, node.Name.LocalName, "ShortName", "Name"));
+                }
+
+                if (null == parentId)
+                {
+                    this.core.OnMessage(WixErrors.DirectoryRootWithoutName(sourceLineNumbers, node.Name.LocalName, "Name"));
+                }
+            }
+            else if (!String.IsNullOrEmpty(name))
+            {
+                if (String.IsNullOrEmpty(shortName))
+                {
+                    if (!name.Equals(".") && !name.Equals("SourceDir") && !this.core.IsValidShortFilename(name, false))
+                    {
+                        shortName = this.core.CreateShortName(name, false, false, "Directory", parentId);
+                    }
+                }
+                else if (name.Equals("."))
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "ShortName", "Name", name));
+                }
+                else if (name.Equals(shortName))
+                {
+                    this.core.OnMessage(WixWarnings.DirectoryRedundantNames(sourceLineNumbers, node.Name.LocalName, "Name", "ShortName", name));
+                }
+            }
+
+            if (String.IsNullOrEmpty(sourceName))
+            {
+                if (!String.IsNullOrEmpty(shortSourceName))
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeWithoutOtherAttributes(sourceLineNumbers, node.Name.LocalName, "ShortSourceName", "SourceName"));
+                }
+            }
+            else
+            {
+                if (String.IsNullOrEmpty(shortSourceName))
+                {
+                    if (!sourceName.Equals(".") && !this.core.IsValidShortFilename(sourceName, false))
+                    {
+                        shortSourceName = this.core.CreateShortName(sourceName, false, false, "Directory", parentId);
+                    }
+                }
+                else if (sourceName.Equals("."))
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "ShortSourceName", "SourceName", sourceName));
+                }
+                else if (sourceName.Equals(shortSourceName))
+                {
+                    this.core.OnMessage(WixWarnings.DirectoryRedundantNames(sourceLineNumbers, node.Name.LocalName, "SourceName", "ShortSourceName", sourceName));
+                }
+            }
+
+            // Update the file source path appropriately.
+            if (fileSourceAttribSet)
+            {
+                if (!fileSource.EndsWith(Path.DirectorySeparatorChar.ToString(), StringComparison.Ordinal))
+                {
+                    fileSource = String.Concat(fileSource, Path.DirectorySeparatorChar);
+                }
+            }
+            else // add the appropriate part of this directory element to the file source.
+            {
+                string append = null;
+                if (this.useShortFileNames)
+                {
+                    append = !String.IsNullOrEmpty(shortSourceName) ? shortSourceName : shortName;
+                }
+
+                if (String.IsNullOrEmpty(append))
+                {
+                    append = !String.IsNullOrEmpty(sourceName) ? sourceName : name;
+                }
+
+                if (!String.IsNullOrEmpty(append))
+                {
+                    fileSource = String.Concat(fileSource, append, Path.DirectorySeparatorChar);
+                }
+            }
+
+            if (null == id)
+            {
+                id = this.core.CreateIdentifier("dir", parentId, name, shortName, sourceName, shortSourceName);
+            }
+
+            // Calculate the DefaultDir for the directory row.
+            defaultDir = String.IsNullOrEmpty(shortName) ? name : String.Concat(shortName, "|", name);
+            if (!String.IsNullOrEmpty(sourceName))
+            {
+                defaultDir = String.Concat(defaultDir, ":", String.IsNullOrEmpty(shortSourceName) ? sourceName : String.Concat(shortSourceName, "|", sourceName));
+            }
+
+            if ("TARGETDIR".Equals(id.Id) && !"SourceDir".Equals(defaultDir))
+            {
+                this.core.OnMessage(WixErrors.IllegalTargetDirDefaultDir(sourceLineNumbers, defaultDir));
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "Component":
+                            this.ParseComponentElement(child, ComplexReferenceParentType.Unknown, null, null, diskId, id.Id, fileSource);
+                            break;
+                        case "Directory":
+                            this.ParseDirectoryElement(child, id.Id, diskId, fileSource);
+                            break;
+                        case "Merge":
+                            this.ParseMergeElement(child, id.Id, diskId);
+                            break;
+                        case "SymbolPath":
+                            if (null != symbols)
+                            {
+                                symbols += ";" + this.ParseSymbolPathElement(child);
+                            }
+                            else
+                            {
+                                symbols = this.ParseSymbolPathElement(child);
+                            }
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "Directory", id);
+                row[1] = parentId;
+                row[2] = defaultDir;
+
+                if (null != componentGuidGenerationSeed)
+                {
+                    Row wixRow = this.core.CreateRow(sourceLineNumbers, "WixDirectory");
+                    wixRow[0] = id.Id;
+                    wixRow[1] = componentGuidGenerationSeed;
+                }
+
+                if (null != symbols)
+                {
+                    WixDeltaPatchSymbolPathsRow symbolRow = (WixDeltaPatchSymbolPathsRow)this.core.CreateRow(sourceLineNumbers, "WixDeltaPatchSymbolPaths", id);
+                    symbolRow.Type = SymbolPathType.Directory;
+                    symbolRow.SymbolPaths = symbols;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses a directory reference element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")]
+        private void ParseDirectoryRefElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string id = null;
+            int diskId = CompilerConstants.IntegerNotSet;
+            string fileSource = String.Empty;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.core.CreateSimpleReference(sourceLineNumbers, "Directory", id);
+                            break;
+                        case "DiskId":
+                            diskId = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 1, short.MaxValue);
+                            break;
+                        case "FileSource":
+                            fileSource = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            if (!String.IsNullOrEmpty(fileSource) && !fileSource.EndsWith(Path.DirectorySeparatorChar.ToString(), StringComparison.Ordinal))
+            {
+                fileSource = String.Concat(fileSource, Path.DirectorySeparatorChar);
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "Component":
+                            this.ParseComponentElement(child, ComplexReferenceParentType.Unknown, null, null, diskId, id, fileSource);
+                            break;
+                        case "Directory":
+                            this.ParseDirectoryElement(child, id, diskId, fileSource);
+                            break;
+                        case "Merge":
+                            this.ParseMergeElement(child, id, diskId);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses a directory search element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="parentSignature">Signature of parent search element.</param>
+        /// <returns>Signature of search element.</returns>
+        private string ParseDirectorySearchElement(XElement node, string parentSignature)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            int depth = CompilerConstants.IntegerNotSet;
+            string path = null;
+            bool assignToProperty = false;
+            string signature = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Depth":
+                            depth = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, short.MaxValue);
+                            break;
+                        case "Path":
+                            path = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "AssignToProperty":
+                            assignToProperty = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                id = this.core.CreateIdentifier("dir", path, depth.ToString());
+            }
+
+            signature = id.Id;
+
+            bool oneChild = false;
+            bool hasFileSearch = false;
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    SourceLineNumber childSourceLineNumbers = Preprocessor.GetSourceLineNumbers(child);
+                    switch (child.Name.LocalName)
+                    {
+                        case "DirectorySearch":
+                            if (oneChild)
+                            {
+                                this.core.OnMessage(WixErrors.TooManySearchElements(childSourceLineNumbers, node.Name.LocalName));
+                            }
+                            oneChild = true;
+                            signature = this.ParseDirectorySearchElement(child, id.Id);
+                            break;
+                        case "DirectorySearchRef":
+                            if (oneChild)
+                            {
+                                this.core.OnMessage(WixErrors.TooManySearchElements(childSourceLineNumbers, node.Name.LocalName));
+                            }
+                            oneChild = true;
+                            signature = this.ParseDirectorySearchRefElement(child, id.Id);
+                            break;
+                        case "FileSearch":
+                            if (oneChild)
+                            {
+                                this.core.OnMessage(WixErrors.TooManySearchElements(sourceLineNumbers, node.Name.LocalName));
+                            }
+                            oneChild = true;
+                            hasFileSearch = true;
+                            signature = this.ParseFileSearchElement(child, id.Id, assignToProperty, depth);
+                            break;
+                        case "FileSearchRef":
+                            if (oneChild)
+                            {
+                                this.core.OnMessage(WixErrors.TooManySearchElements(sourceLineNumbers, node.Name.LocalName));
+                            }
+                            oneChild = true;
+                            signature = this.ParseSimpleRefElement(child, "Signature");
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+
+                    // If AssignToProperty is set, only a FileSearch
+                    // or no child element can be nested.
+                    if (assignToProperty)
+                    {
+                        if (!hasFileSearch)
+                        {
+                            this.core.OnMessage(WixErrors.IllegalParentAttributeWhenNested(sourceLineNumbers, node.Name.LocalName, "AssignToProperty", child.Name.LocalName));
+                        }
+                        else if (!oneChild)
+                        {
+                            // This a normal directory search.
+                            assignToProperty = false;
+                        }
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                Identifier rowId = id;
+
+                // If AssignToProperty is set, the DrLocator row created by
+                // ParseFileSearchElement creates the directory entry to return
+                // and the row created here is for the file search.
+                if (assignToProperty)
+                {
+                    rowId = new Identifier(signature, AccessModifier.Private);
+
+                    // The property should be set to the directory search Id.
+                    signature = id.Id;
+                }
+
+                Row row = this.core.CreateRow(sourceLineNumbers, "DrLocator", rowId);
+                row[1] = parentSignature;
+                row[2] = path;
+                if (CompilerConstants.IntegerNotSet != depth)
+                {
+                    row[3] = depth;
+                }
+            }
+
+            return signature;
+        }
+
+        /// <summary>
+        /// Parses a directory search reference element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="parentSignature">Signature of parent search element.</param>
+        /// <returns>Signature of search element.</returns>
+        private string ParseDirectorySearchRefElement(XElement node, string parentSignature)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            Identifier parent = null;
+            string path = null;
+            string signature = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Parent":
+                            parent = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Path":
+                            path = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null != parent)
+            {
+                if (!String.IsNullOrEmpty(parentSignature))
+                {
+                    this.core.OnMessage(WixErrors.CanNotHaveTwoParents(sourceLineNumbers, id.Id, parent.Id, parentSignature));
+                }
+                else
+                {
+                    parentSignature = parent.Id;
+                }
+            }
+
+            if (null == id)
+            {
+                id = this.core.CreateIdentifier("dsr", parentSignature, path);
+            }
+
+            signature = id.Id;
+
+            bool oneChild = false;
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    SourceLineNumber childSourceLineNumbers = Preprocessor.GetSourceLineNumbers(child);
+                    switch (child.Name.LocalName)
+                    {
+                        case "DirectorySearch":
+                            if (oneChild)
+                            {
+                                this.core.OnMessage(WixErrors.TooManySearchElements(childSourceLineNumbers, node.Name.LocalName));
+                            }
+                            oneChild = true;
+                            signature = this.ParseDirectorySearchElement(child, id.Id);
+                            break;
+                        case "DirectorySearchRef":
+                            if (oneChild)
+                            {
+                                this.core.OnMessage(WixErrors.TooManySearchElements(childSourceLineNumbers, node.Name.LocalName));
+                            }
+                            oneChild = true;
+                            signature = this.ParseDirectorySearchRefElement(child, id.Id);
+                            break;
+                        case "FileSearch":
+                            if (oneChild)
+                            {
+                                this.core.OnMessage(WixErrors.TooManySearchElements(childSourceLineNumbers, node.Name.LocalName));
+                            }
+                            oneChild = true;
+                            signature = this.ParseFileSearchElement(child, id.Id, false, CompilerConstants.IntegerNotSet);
+                            break;
+                        case "FileSearchRef":
+                            if (oneChild)
+                            {
+                                this.core.OnMessage(WixErrors.TooManySearchElements(sourceLineNumbers, node.Name.LocalName));
+                            }
+                            oneChild = true;
+                            signature = this.ParseSimpleRefElement(child, "Signature");
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+
+            this.core.CreateSimpleReference(sourceLineNumbers, "DrLocator", id.Id, parentSignature, path);
+
+            return signature;
+        }
+
+        /// <summary>
+        /// Parses a feature element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="parentType">The type of parent.</param>
+        /// <param name="parentId">Optional identifer for parent feature.</param>
+        /// <param name="lastDisplay">Display value for last feature used to get the features to display in the same order as specified 
+        /// in the source code.</param>
+        [SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")]
+        private void ParseFeatureElement(XElement node, ComplexReferenceParentType parentType, string parentId, ref int lastDisplay)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            string allowAdvertise = null;
+            int bits = 0;
+            string configurableDirectory = null;
+            string description = null;
+            string display = "collapse";
+            YesNoType followParent = YesNoType.NotSet;
+            string installDefault = null;
+            int level = 1;
+            string title = null;
+            string typicalDefault = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Absent":
+                            string absent = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (0 < absent.Length)
+                            {
+                                Wix.Feature.AbsentType absentType = Wix.Feature.ParseAbsentType(absent);
+                                switch (absentType)
+                                {
+                                    case Wix.Feature.AbsentType.allow: // this is the default
+                                        break;
+                                    case Wix.Feature.AbsentType.disallow:
+                                        bits = bits | MsiInterop.MsidbFeatureAttributesUIDisallowAbsent;
+                                        break;
+                                    default:
+                                        this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, absent, "allow", "disallow"));
+                                        break;
+                                }
+                            }
+                            break;
+                        case "AllowAdvertise":
+                            allowAdvertise = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (0 < allowAdvertise.Length)
+                            {
+                                Wix.Feature.AllowAdvertiseType allowAdvertiseType = Wix.Feature.ParseAllowAdvertiseType(allowAdvertise);
+                                switch (allowAdvertiseType)
+                                {
+                                    case Wix.Feature.AllowAdvertiseType.no:
+                                        bits |= MsiInterop.MsidbFeatureAttributesDisallowAdvertise;
+                                        break;
+                                    case Wix.Feature.AllowAdvertiseType.system:
+                                        bits |= MsiInterop.MsidbFeatureAttributesNoUnsupportedAdvertise;
+                                        break;
+                                    case Wix.Feature.AllowAdvertiseType.yes: // this is the default
+                                        break;
+                                    default:
+                                        this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, allowAdvertise, "no", "system", "yes"));
+                                        break;
+                                }
+                            }
+                            break;
+                        case "ConfigurableDirectory":
+                            configurableDirectory = this.core.CreateDirectoryReferenceFromInlineSyntax(sourceLineNumbers, attrib, null);
+                            break;
+                        case "Description":
+                            description = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Display":
+                            display = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "InstallDefault":
+                            installDefault = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (0 < installDefault.Length)
+                            {
+                                Wix.Feature.InstallDefaultType installDefaultType = Wix.Feature.ParseInstallDefaultType(installDefault);
+                                switch (installDefaultType)
+                                {
+                                    case Wix.Feature.InstallDefaultType.followParent:
+                                        if (ComplexReferenceParentType.Product == parentType)
+                                        {
+                                            this.core.OnMessage(WixErrors.RootFeatureCannotFollowParent(sourceLineNumbers));
+                                        }
+                                        bits = bits | MsiInterop.MsidbFeatureAttributesFollowParent;
+                                        break;
+                                    case Wix.Feature.InstallDefaultType.local: // this is the default
+                                        break;
+                                    case Wix.Feature.InstallDefaultType.source:
+                                        bits = bits | MsiInterop.MsidbFeatureAttributesFavorSource;
+                                        break;
+                                    default:
+                                        this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, installDefault, "followParent", "local", "source"));
+                                        break;
+                                }
+                            }
+                            break;
+                        case "Level":
+                            level = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, short.MaxValue);
+                            break;
+                        case "Title":
+                            title = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if ("PUT-FEATURE-TITLE-HERE" == title)
+                            {
+                                this.core.OnMessage(WixWarnings.PlaceholderValue(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, title));
+                            }
+                            break;
+                        case "TypicalDefault":
+                            typicalDefault = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (0 < typicalDefault.Length)
+                            {
+                                Wix.Feature.TypicalDefaultType typicalDefaultType = Wix.Feature.ParseTypicalDefaultType(typicalDefault);
+                                switch (typicalDefaultType)
+                                {
+                                    case Wix.Feature.TypicalDefaultType.advertise:
+                                        bits = bits | MsiInterop.MsidbFeatureAttributesFavorAdvertise;
+                                        break;
+                                    case Wix.Feature.TypicalDefaultType.install: // this is the default
+                                        break;
+                                    default:
+                                        this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, typicalDefault, "advertise", "install"));
+                                        break;
+                                }
+                            }
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+                id = Identifier.Invalid;
+            }
+            else if (38 < id.Id.Length)
+            {
+                this.core.OnMessage(WixErrors.FeatureNameTooLong(sourceLineNumbers, node.Name.LocalName, "Id", id.Id));
+            }
+
+            if (null != configurableDirectory && configurableDirectory.ToUpper(CultureInfo.InvariantCulture) != configurableDirectory)
+            {
+                this.core.OnMessage(WixErrors.FeatureConfigurableDirectoryNotUppercase(sourceLineNumbers, node.Name.LocalName, "ConfigurableDirectory", configurableDirectory));
+            }
+
+            if ("advertise" == typicalDefault && "no" == allowAdvertise)
+            {
+                this.core.OnMessage(WixErrors.FeatureCannotFavorAndDisallowAdvertise(sourceLineNumbers, node.Name.LocalName, "TypicalDefault", typicalDefault, "AllowAdvertise", allowAdvertise));
+            }
+
+            if (YesNoType.Yes == followParent && ("local" == installDefault || "source" == installDefault))
+            {
+                this.core.OnMessage(WixErrors.FeatureCannotFollowParentAndFavorLocalOrSource(sourceLineNumbers, node.Name.LocalName, "InstallDefault", "FollowParent", "yes"));
+            }
+
+            int childDisplay = 0;
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "ComponentGroupRef":
+                            this.ParseComponentGroupRefElement(child, ComplexReferenceParentType.Feature, id.Id, null);
+                            break;
+                        case "ComponentRef":
+                            this.ParseComponentRefElement(child, ComplexReferenceParentType.Feature, id.Id, null);
+                            break;
+                        case "Component":
+                            this.ParseComponentElement(child, ComplexReferenceParentType.Feature, id.Id, null, CompilerConstants.IntegerNotSet, null, null);
+                            break;
+                        case "Condition":
+                            this.ParseConditionElement(child, node.Name.LocalName, id.Id, null);
+                            break;
+                        case "Feature":
+                            this.ParseFeatureElement(child, ComplexReferenceParentType.Feature, id.Id, ref childDisplay);
+                            break;
+                        case "FeatureGroupRef":
+                            this.ParseFeatureGroupRefElement(child, ComplexReferenceParentType.Feature, id.Id);
+                            break;
+                        case "FeatureRef":
+                            this.ParseFeatureRefElement(child, ComplexReferenceParentType.Feature, id.Id);
+                            break;
+                        case "MergeRef":
+                            this.ParseMergeRefElement(child, ComplexReferenceParentType.Feature, id.Id);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "Feature", id);
+                row[1] = null; // this column is set in the linker
+                row[2] = title;
+                row[3] = description;
+                if (0 < display.Length)
+                {
+                    switch (display)
+                    {
+                        case "collapse":
+                            lastDisplay = (lastDisplay | 1) + 1;
+                            row[4] = lastDisplay;
+                            break;
+                        case "expand":
+                            lastDisplay = (lastDisplay + 1) | 1;
+                            row[4] = lastDisplay;
+                            break;
+                        case "hidden":
+                            row[4] = 0;
+                            break;
+                        default:
+                            int value;
+                            if (!Int32.TryParse(display, NumberStyles.Integer, CultureInfo.InvariantCulture, out value))
+                            {
+                                this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, "Display", display, "collapse", "expand", "hidden"));
+                            }
+                            else
+                            {
+                                row[4] = value;
+                                // save the display value of this row (if its not hidden) for subsequent rows
+                                if (0 != (int)row[4])
+                                {
+                                    lastDisplay = (int)row[4];
+                                }
+                            }
+                            break;
+                    }
+                }
+                row[5] = level;
+                row[6] = configurableDirectory;
+                row[7] = bits;
+
+                if (ComplexReferenceParentType.Unknown != parentType)
+                {
+                    this.core.CreateComplexReference(sourceLineNumbers, parentType, parentId, null, ComplexReferenceChildType.Feature, id.Id, false);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses a feature reference element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="parentType">The type of parent.</param>
+        /// <param name="parentId">Optional identifier for parent feature.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")]
+        private void ParseFeatureRefElement(XElement node, ComplexReferenceParentType parentType, string parentId)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string id = null;
+            YesNoType ignoreParent = YesNoType.NotSet;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.core.CreateSimpleReference(sourceLineNumbers, "Feature", id);
+                            break;
+                        case "IgnoreParent":
+                            ignoreParent = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            int lastDisplay = 0;
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "ComponentGroupRef":
+                            this.ParseComponentGroupRefElement(child, ComplexReferenceParentType.Feature, id, null);
+                            break;
+                        case "ComponentRef":
+                            this.ParseComponentRefElement(child, ComplexReferenceParentType.Feature, id, null);
+                            break;
+                        case "Component":
+                            this.ParseComponentElement(child, ComplexReferenceParentType.Feature, id, null, CompilerConstants.IntegerNotSet, null, null);
+                            break;
+                        case "Feature":
+                            this.ParseFeatureElement(child, ComplexReferenceParentType.Feature, id, ref lastDisplay);
+                            break;
+                        case "FeatureGroup":
+                            this.ParseFeatureGroupElement(child, ComplexReferenceParentType.Feature, id);
+                            break;
+                        case "FeatureGroupRef":
+                            this.ParseFeatureGroupRefElement(child, ComplexReferenceParentType.Feature, id);
+                            break;
+                        case "FeatureRef":
+                            this.ParseFeatureRefElement(child, ComplexReferenceParentType.Feature, id);
+                            break;
+                        case "MergeRef":
+                            this.ParseMergeRefElement(child, ComplexReferenceParentType.Feature, id);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                if (ComplexReferenceParentType.Unknown != parentType && YesNoType.Yes != ignoreParent)
+                {
+                    this.core.CreateComplexReference(sourceLineNumbers, parentType, parentId, null, ComplexReferenceChildType.Feature, id, false);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses a feature group element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")]
+        private void ParseFeatureGroupElement(XElement node, ComplexReferenceParentType parentType, string parentId)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+                id = Identifier.Invalid;
+            }
+
+            int lastDisplay = 0;
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "ComponentGroupRef":
+                            this.ParseComponentGroupRefElement(child, ComplexReferenceParentType.FeatureGroup, id.Id, null);
+                            break;
+                        case "ComponentRef":
+                            this.ParseComponentRefElement(child, ComplexReferenceParentType.FeatureGroup, id.Id, null);
+                            break;
+                        case "Component":
+                            this.ParseComponentElement(child, ComplexReferenceParentType.FeatureGroup, id.Id, null, CompilerConstants.IntegerNotSet, null, null);
+                            break;
+                        case "Feature":
+                            this.ParseFeatureElement(child, ComplexReferenceParentType.FeatureGroup, id.Id, ref lastDisplay);
+                            break;
+                        case "FeatureGroupRef":
+                            this.ParseFeatureGroupRefElement(child, ComplexReferenceParentType.FeatureGroup, id.Id);
+                            break;
+                        case "FeatureRef":
+                            this.ParseFeatureRefElement(child, ComplexReferenceParentType.FeatureGroup, id.Id);
+                            break;
+                        case "MergeRef":
+                            this.ParseMergeRefElement(child, ComplexReferenceParentType.FeatureGroup, id.Id);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "WixFeatureGroup", id);
+
+                //Add this FeatureGroup and its parent in WixGroup.
+                this.core.CreateWixGroupRow(sourceLineNumbers, parentType, parentId, ComplexReferenceChildType.FeatureGroup, id.Id);
+            }
+        }
+
+        /// <summary>
+        /// Parses a feature group reference element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="parentType">The type of parent.</param>
+        /// <param name="parentId">Identifier of parent element.</param>
+        private void ParseFeatureGroupRefElement(XElement node, ComplexReferenceParentType parentType, string parentId)
+        {
+            Debug.Assert(ComplexReferenceParentType.Feature == parentType || ComplexReferenceParentType.FeatureGroup == parentType || ComplexReferenceParentType.ComponentGroup == parentType || ComplexReferenceParentType.Product == parentType);
+
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string id = null;
+            YesNoType ignoreParent = YesNoType.NotSet;
+            YesNoType primary = YesNoType.NotSet;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            this.core.CreateSimpleReference(sourceLineNumbers, "WixFeatureGroup", id);
+                            break;
+                        case "IgnoreParent":
+                            ignoreParent = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Primary":
+                            primary = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                if (YesNoType.Yes != ignoreParent)
+                {
+                    this.core.CreateComplexReference(sourceLineNumbers, parentType, parentId, null, ComplexReferenceChildType.FeatureGroup, id, (YesNoType.Yes == primary));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses an environment element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="componentId">Identifier of parent component.</param>
+        private void ParseEnvironmentElement(XElement node, string componentId)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            string action = null;
+            string name = null;
+            Wix.Environment.PartType partType = Wix.Environment.PartType.NotSet;
+            string part = null;
+            bool permanent = false;
+            string separator = ";"; // default to ';'
+            bool system = false;
+            string text = null;
+            string uninstall = "-"; // default to remove at uninstall
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Action":
+                            string value = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (0 < value.Length)
+                            {
+                                Wix.Environment.ActionType actionType = Wix.Environment.ParseActionType(value);
+                                switch (actionType)
+                                {
+                                    case Wix.Environment.ActionType.create:
+                                        action = "+";
+                                        break;
+                                    case Wix.Environment.ActionType.set:
+                                        action = "=";
+                                        break;
+                                    case Wix.Environment.ActionType.remove:
+                                        action = "!";
+                                        break;
+                                    default:
+                                        this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, value, "create", "set", "remove"));
+                                        break;
+                                }
+                            }
+                            break;
+                        case "Name":
+                            name = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Part":
+                            part = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (!Wix.Environment.TryParsePartType(part, out partType))
+                            {
+                                this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, "Part", part, "all", "first", "last"));
+                            }
+                            break;
+                        case "Permanent":
+                            permanent = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Separator":
+                            separator = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "System":
+                            system = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Value":
+                            text = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                id = this.core.CreateIdentifier("env", action, name, part, system.ToString());
+            }
+
+            if (null == name)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Name"));
+            }
+
+            if (Wix.Environment.PartType.NotSet != partType)
+            {
+                if ("+" == action)
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "Part", "Action", "create"));
+                }
+
+                switch (partType)
+                {
+                    case Wix.Environment.PartType.all:
+                        break;
+                    case Wix.Environment.PartType.first:
+                        text = String.Concat(text, separator, "[~]");
+                        break;
+                    case Wix.Environment.PartType.last:
+                        text = String.Concat("[~]", separator, text);
+                        break;
+                }
+            }
+
+            if (permanent)
+            {
+                uninstall = null;
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "Environment", id);
+                row[1] = String.Concat(action, uninstall, system ? "*" : String.Empty, name);
+                row[2] = text;
+                row[3] = componentId;
+            }
+        }
+
+        /// <summary>
+        /// Parses an error element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        private void ParseErrorElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            int id = CompilerConstants.IntegerNotSet;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, short.MaxValue);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (CompilerConstants.IntegerNotSet == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+                id = CompilerConstants.IllegalInteger;
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "Error");
+                row[0] = id;
+                row[1] = Common.GetInnerText(node); // TODO: *
+            }
+        }
+
+        /// <summary>
+        /// Parses an extension element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="componentId">Identifier of parent component.</param>
+        /// <param name="advertise">Flag if this extension is advertised.</param>
+        /// <param name="progId">ProgId for extension.</param>
+        private void ParseExtensionElement(XElement node, string componentId, YesNoType advertise, string progId)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string extension = null;
+            string mime = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            extension = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Advertise":
+                            YesNoType extensionAdvertise = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            if ((YesNoType.No == advertise && YesNoType.Yes == extensionAdvertise) || (YesNoType.Yes == advertise && YesNoType.No == extensionAdvertise))
+                            {
+                                this.core.OnMessage(WixErrors.AdvertiseStateMustMatch(sourceLineNumbers, extensionAdvertise.ToString(), advertise.ToString()));
+                            }
+                            advertise = extensionAdvertise;
+                            break;
+                        case "ContentType":
+                            mime = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    Dictionary<string, string> context = new Dictionary<string, string>() { { "ProgId", progId }, { "ComponentId", componentId } };
+                    this.core.ParseExtensionAttribute(node, attrib, context);
+                }
+            }
+
+            if (YesNoType.NotSet == advertise)
+            {
+                advertise = YesNoType.No;
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "Verb":
+                            this.ParseVerbElement(child, extension, progId, componentId, advertise);
+                            break;
+                        case "MIME":
+                            string newMime = this.ParseMIMEElement(child, extension, componentId, advertise);
+                            if (null != newMime && null == mime)
+                            {
+                                mime = newMime;
+                            }
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+
+            if (YesNoType.Yes == advertise)
+            {
+                if (!this.core.EncounteredError)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "Extension");
+                    row[0] = extension;
+                    row[1] = componentId;
+                    row[2] = progId;
+                    row[3] = mime;
+                    row[4] = Guid.Empty.ToString("B");
+
+                    this.core.EnsureTable(sourceLineNumbers, "Verb");
+                }
+            }
+            else if (YesNoType.No == advertise)
+            {
+                this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat(".", extension), String.Empty, progId, componentId); // Extension
+                if (null != mime)
+                {
+                    this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat(".", extension), "Content Type", mime, componentId); // Extension's MIME ContentType
+                }
+            }
+        }
+
+
+        /// <summary>
+        /// Parses a file element.
+        /// </summary>
+        /// <param name="node">File element to parse.</param>
+        /// <param name="componentId">Parent's component id.</param>
+        /// <param name="directoryId">Ancestor's directory id.</param>
+        /// <param name="diskId">Disk id inherited from parent component.</param>
+        /// <param name="sourcePath">Default source path of parent directory.</param>
+        /// <param name="possibleKeyPath">This will be set with the possible keyPath for the parent component.</param>
+        /// <param name="win64Component">true if the component is 64-bit.</param>
+        /// <returns>Yes if this element was marked as the parent component's key path, No if explicitly marked as not being a key path, or NotSet otherwise.</returns>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")]
+        private YesNoType ParseFileElement(XElement node, string componentId, string directoryId, int diskId, string sourcePath, out string possibleKeyPath, bool win64Component, string componentGuid)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            FileAssemblyType assemblyType = FileAssemblyType.NotAnAssembly;
+            string assemblyApplication = null;
+            string assemblyManifest = null;
+            string bindPath = null;
+            int bits = MsiInterop.MsidbFileAttributesVital; // assume all files are vital.
+            string companionFile = null;
+            string defaultLanguage = null;
+            int defaultSize = 0;
+            string defaultVersion = null;
+            string fontTitle = null;
+            bool generatedShortFileName = false;
+            YesNoType keyPath = YesNoType.NotSet;
+            string name = null;
+            int patchGroup = CompilerConstants.IntegerNotSet;
+            bool patchIgnore = false;
+            bool patchIncludeWholeFile = false;
+            bool patchAllowIgnoreOnError = false;
+
+            string ignoreLengths = null;
+            string ignoreOffsets = null;
+            string protectLengths = null;
+            string protectOffsets = null;
+            string symbols = null;
+
+            string procArch = null;
+            int selfRegCost = CompilerConstants.IntegerNotSet;
+            string shortName = null;
+            string source = sourcePath;   // assume we'll use the parents as the source for this file
+            bool sourceSet = false;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Assembly":
+                            string assemblyValue = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (0 < assemblyValue.Length)
+                            {
+                                Wix.File.AssemblyType parsedAssemblyType = Wix.File.ParseAssemblyType(assemblyValue);
+                                switch (parsedAssemblyType)
+                                {
+                                    case Wix.File.AssemblyType.net:
+                                        assemblyType = FileAssemblyType.DotNetAssembly;
+                                        break;
+                                    case Wix.File.AssemblyType.no:
+                                        assemblyType = FileAssemblyType.NotAnAssembly;
+                                        break;
+                                    case Wix.File.AssemblyType.win32:
+                                        assemblyType = FileAssemblyType.Win32Assembly;
+                                        break;
+                                    default:
+                                        this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, "File", "Assembly", assemblyValue, "no", "win32", ".net"));
+                                        break;
+                                }
+                            }
+                            break;
+                        case "AssemblyApplication":
+                            assemblyApplication = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.core.CreateSimpleReference(sourceLineNumbers, "File", assemblyApplication);
+                            break;
+                        case "AssemblyManifest":
+                            assemblyManifest = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.core.CreateSimpleReference(sourceLineNumbers, "File", assemblyManifest);
+                            break;
+                        case "BindPath":
+                            bindPath = this.core.GetAttributeValue(sourceLineNumbers, attrib, EmptyRule.CanBeEmpty);
+                            break;
+                        case "Checksum":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                bits |= MsiInterop.MsidbFileAttributesChecksum;
+                            }
+                            break;
+                        case "CompanionFile":
+                            companionFile = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.core.CreateSimpleReference(sourceLineNumbers, "File", companionFile);
+                            break;
+                        case "Compressed":
+                            YesNoDefaultType compressed = this.core.GetAttributeYesNoDefaultValue(sourceLineNumbers, attrib);
+                            if (YesNoDefaultType.Yes == compressed)
+                            {
+                                bits |= MsiInterop.MsidbFileAttributesCompressed;
+                            }
+                            else if (YesNoDefaultType.No == compressed)
+                            {
+                                bits |= MsiInterop.MsidbFileAttributesNoncompressed;
+                            }
+                            break;
+                        case "DefaultLanguage":
+                            defaultLanguage = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "DefaultSize":
+                            defaultSize = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, int.MaxValue);
+                            break;
+                        case "DefaultVersion":
+                            defaultVersion = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "DiskId":
+                            diskId = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 1, short.MaxValue);
+                            break;
+                        case "FontTitle":
+                            fontTitle = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Hidden":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                bits |= MsiInterop.MsidbFileAttributesHidden;
+                            }
+                            break;
+                        case "KeyPath":
+                            keyPath = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Name":
+                            name = this.core.GetAttributeLongFilename(sourceLineNumbers, attrib, false);
+                            break;
+                        case "PatchGroup":
+                            patchGroup = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 1, int.MaxValue);
+                            break;
+                        case "PatchIgnore":
+                            patchIgnore = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "PatchWholeFile":
+                            patchIncludeWholeFile = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "PatchAllowIgnoreOnError":
+                            patchAllowIgnoreOnError = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ProcessorArchitecture":
+                            string procArchValue = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (0 < procArchValue.Length)
+                            {
+                                Wix.File.ProcessorArchitectureType procArchType = Wix.File.ParseProcessorArchitectureType(procArchValue);
+                                switch (procArchType)
+                                {
+                                    case Wix.File.ProcessorArchitectureType.msil:
+                                        procArch = "MSIL";
+                                        break;
+                                    case Wix.File.ProcessorArchitectureType.x86:
+                                        procArch = "x86";
+                                        break;
+                                    case Wix.File.ProcessorArchitectureType.x64:
+                                        procArch = "amd64";
+                                        break;
+                                    case Wix.File.ProcessorArchitectureType.ia64:
+                                        procArch = "ia64";
+                                        break;
+                                    default:
+                                        this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, "File", "ProcessorArchitecture", procArchValue, "msil", "x86", "x64", "ia64"));
+                                        break;
+                                }
+                            }
+                            break;
+                        case "ReadOnly":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                bits |= MsiInterop.MsidbFileAttributesReadOnly;
+                            }
+                            break;
+                        case "SelfRegCost":
+                            selfRegCost = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, short.MaxValue);
+                            break;
+                        case "ShortName":
+                            shortName = this.core.GetAttributeShortFilename(sourceLineNumbers, attrib, false);
+                            break;
+                        case "Source":
+                            source = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            sourceSet = true;
+                            break;
+                        case "System":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                bits |= MsiInterop.MsidbFileAttributesSystem;
+                            }
+                            break;
+                        case "TrueType":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                fontTitle = String.Empty;
+                            }
+                            break;
+                        case "Vital":
+                            YesNoType isVital = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            if (YesNoType.Yes == isVital)
+                            {
+                                bits |= MsiInterop.MsidbFileAttributesVital;
+                            }
+                            else if (YesNoType.No == isVital)
+                            {
+                                bits &= ~MsiInterop.MsidbFileAttributesVital;
+                            }
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null != companionFile)
+            {
+                // the companion file cannot be the key path of a component
+                if (YesNoType.Yes == keyPath)
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "CompanionFile", "KeyPath", "yes"));
+                }
+            }
+
+            if (sourceSet && !source.EndsWith(Path.DirectorySeparatorChar.ToString(), StringComparison.Ordinal) && null == name)
+            {
+                name = Path.GetFileName(source);
+                if (!this.core.IsValidLongFilename(name, false))
+                {
+                    this.core.OnMessage(WixErrors.IllegalLongFilename(sourceLineNumbers, node.Name.LocalName, "Source", name));
+                }
+            }
+
+            // generate a short file name
+            if (null == shortName && (null != name && !this.core.IsValidShortFilename(name, false)))
+            {
+                shortName = this.core.CreateShortName(name, true, false, node.Name.LocalName, directoryId);
+                generatedShortFileName = true;
+            }
+
+            if (null == id)
+            {
+                id = this.core.CreateIdentifier("fil", directoryId, name ?? shortName);
+            }
+
+            if (!this.compilingModule && CompilerConstants.IntegerNotSet == diskId)
+            {
+                diskId = 1; // default to first Media
+            }
+
+            if (null != defaultVersion && null != companionFile)
+            {
+                this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "DefaultVersion", "CompanionFile", companionFile));
+            }
+
+            if (FileAssemblyType.NotAnAssembly == assemblyType)
+            {
+                if (null != assemblyManifest)
+                {
+                    this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Assembly", "AssemblyManifest"));
+                }
+
+                if (null != assemblyApplication)
+                {
+                    this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Assembly", "AssemblyApplication"));
+                }
+            }
+            else
+            {
+                if (FileAssemblyType.Win32Assembly == assemblyType && null == assemblyManifest)
+                {
+                    this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "AssemblyManifest", "Assembly", "win32"));
+                }
+
+                // allow "*" guid components to omit explicit KeyPath as they can have only one file and therefore this file is the keypath
+                if (YesNoType.Yes != keyPath && "*" != componentGuid)
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeValueWithoutOtherAttribute(sourceLineNumbers, node.Name.LocalName, "Assembly", (FileAssemblyType.DotNetAssembly == assemblyType ? ".net" : "win32"), "KeyPath", "yes"));
+                }
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "AppId":
+                            this.ParseAppIdElement(child, componentId, YesNoType.NotSet, id.Id, null, null);
+                            break;
+                        case "AssemblyName":
+                            this.ParseAssemblyName(child, componentId);
+                            break;
+                        case "Class":
+                            this.ParseClassElement(child, componentId, YesNoType.NotSet, id.Id, null, null, null);
+                            break;
+                        case "CopyFile":
+                            this.ParseCopyFileElement(child, componentId, id.Id);
+                            break;
+                        case "IgnoreRange":
+                            this.ParseRangeElement(child, ref ignoreOffsets, ref ignoreLengths);
+                            break;
+                        case "ODBCDriver":
+                            this.ParseODBCDriverOrTranslator(child, componentId, id.Id, this.tableDefinitions["ODBCDriver"]);
+                            break;
+                        case "ODBCTranslator":
+                            this.ParseODBCDriverOrTranslator(child, componentId, id.Id, this.tableDefinitions["ODBCTranslator"]);
+                            break;
+                        case "Permission":
+                            this.ParsePermissionElement(child, id.Id, "File");
+                            break;
+                        case "PermissionEx":
+                            this.ParsePermissionExElement(child, id.Id, "File");
+                            break;
+                        case "ProtectRange":
+                            this.ParseRangeElement(child, ref protectOffsets, ref protectLengths);
+                            break;
+                        case "Shortcut":
+                            this.ParseShortcutElement(child, componentId, node.Name.LocalName, id.Id, keyPath);
+                            break;
+                        case "SymbolPath":
+                            if (null != symbols)
+                            {
+                                symbols += ";" + this.ParseSymbolPathElement(child);
+                            }
+                            else
+                            {
+                                symbols = this.ParseSymbolPathElement(child);
+                            }
+                            break;
+                        case "TypeLib":
+                            this.ParseTypeLibElement(child, componentId, id.Id, win64Component);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    Dictionary<string, string> context = new Dictionary<string, string>() { { "FileId", id.Id }, { "ComponentId", componentId }, { "Win64", win64Component.ToString() } };
+                    this.core.ParseExtensionElement(node, child, context);
+                }
+            }
+
+
+            if (!this.core.EncounteredError)
+            {
+                PatchAttributeType patchAttributes = PatchAttributeType.None;
+                if (patchIgnore)
+                {
+                    patchAttributes |= PatchAttributeType.Ignore;
+                }
+                if (patchIncludeWholeFile)
+                {
+                    patchAttributes |= PatchAttributeType.IncludeWholeFile;
+                }
+                if (patchAllowIgnoreOnError)
+                {
+                    patchAttributes |= PatchAttributeType.AllowIgnoreOnError;
+                }
+
+                if (String.IsNullOrEmpty(source))
+                {
+                    if (!this.useShortFileNames && null != name)
+                    {
+                        source = name;
+                    }
+                    else
+                    {
+                        source = shortName;
+                    }
+                }
+                else if (source.EndsWith(Path.DirectorySeparatorChar.ToString(), StringComparison.Ordinal)) // if source relies on parent directories, append the file name
+                {
+                    if (!this.useShortFileNames && null != name)
+                    {
+                        source = Path.Combine(source, name);
+                    }
+                    else
+                    {
+                        source = Path.Combine(source, shortName);
+                    }
+                }
+
+                FileRow fileRow = (FileRow)this.core.CreateRow(sourceLineNumbers, "File", id);
+                fileRow[1] = componentId;
+                fileRow[2] = GetMsiFilenameValue(shortName, name);
+                fileRow[3] = defaultSize;
+                if (null != companionFile)
+                {
+                    fileRow[4] = companionFile;
+                }
+                else if (null != defaultVersion)
+                {
+                    fileRow[4] = defaultVersion;
+                }
+                fileRow[5] = defaultLanguage;
+                fileRow[6] = bits;
+
+                // the Sequence row is set in the binder
+
+                WixFileRow wixFileRow = (WixFileRow)this.core.CreateRow(sourceLineNumbers, "WixFile", id);
+                wixFileRow.AssemblyType = assemblyType;
+                wixFileRow.AssemblyManifest = assemblyManifest;
+                wixFileRow.AssemblyApplication = assemblyApplication;
+                wixFileRow.Directory = directoryId;
+                wixFileRow.DiskId = (CompilerConstants.IntegerNotSet == diskId) ? 0 : diskId;
+                wixFileRow.Source = source;
+                wixFileRow.ProcessorArchitecture = procArch;
+                wixFileRow.PatchGroup = (CompilerConstants.IntegerNotSet != patchGroup ? patchGroup : -1);
+                wixFileRow.Attributes = (generatedShortFileName ? 0x1 : 0x0);
+                wixFileRow.PatchAttributes = patchAttributes;
+
+                // Always create a delta patch row for this file since other elements (like Component and Media) may
+                // want to add symbol paths to it.
+                WixDeltaPatchFileRow deltaPatchFileRow = (WixDeltaPatchFileRow)this.core.CreateRow(sourceLineNumbers, "WixDeltaPatchFile", id);
+                deltaPatchFileRow.RetainLengths = protectLengths;
+                deltaPatchFileRow.IgnoreOffsets = ignoreOffsets;
+                deltaPatchFileRow.IgnoreLengths = ignoreLengths;
+                deltaPatchFileRow.RetainOffsets = protectOffsets;
+
+                if (null != symbols)
+                {
+                    WixDeltaPatchSymbolPathsRow symbolRow = (WixDeltaPatchSymbolPathsRow)this.core.CreateRow(sourceLineNumbers, "WixDeltaPatchSymbolPaths", id);
+                    symbolRow.Type = SymbolPathType.File;
+                    symbolRow.SymbolPaths = symbols;
+                }
+
+                if (FileAssemblyType.NotAnAssembly != assemblyType)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "MsiAssembly");
+                    row[0] = componentId;
+                    row[1] = Guid.Empty.ToString("B");
+                    row[2] = assemblyManifest;
+                    row[3] = assemblyApplication;
+                    row[4] = (FileAssemblyType.DotNetAssembly == assemblyType) ? 0 : 1;
+                }
+
+                if (null != bindPath)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "BindImage");
+                    row[0] = id.Id;
+                    row[1] = bindPath;
+
+                    // TODO: technically speaking each of the properties in the "bindPath" should be added as references, but how much do we really care about BindImage?
+                }
+
+                if (CompilerConstants.IntegerNotSet != selfRegCost)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "SelfReg");
+                    row[0] = id.Id;
+                    row[1] = selfRegCost;
+                }
+
+                if (null != fontTitle)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "Font");
+                    row[0] = id.Id;
+                    row[1] = fontTitle;
+                }
+            }
+
+            this.core.CreateSimpleReference(sourceLineNumbers, "Media", diskId.ToString(CultureInfo.InvariantCulture.NumberFormat));
+
+            // If this component does not have a companion file this file is a possible keypath.
+            possibleKeyPath = null;
+            if (null == companionFile)
+            {
+                possibleKeyPath = id.Id;
+            }
+
+            return keyPath;
+        }
+
+        /// <summary>
+        /// Parses a file search element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="parentSignature">Signature of parent search element.</param>
+        /// <param name="parentDirectorySearch">Whether this search element is used to search for the parent directory.</param>
+        /// <param name="parentDepth">The depth specified by the parent search element.</param>
+        /// <returns>Signature of search element.</returns>
+        private string ParseFileSearchElement(XElement node, string parentSignature, bool parentDirectorySearch, int parentDepth)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            string languages = null;
+            int minDate = CompilerConstants.IntegerNotSet;
+            int maxDate = CompilerConstants.IntegerNotSet;
+            int maxSize = CompilerConstants.IntegerNotSet;
+            int minSize = CompilerConstants.IntegerNotSet;
+            string maxVersion = null;
+            string minVersion = null;
+            string name = null;
+            string shortName = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Name":
+                            name = this.core.GetAttributeLongFilename(sourceLineNumbers, attrib, false);
+                            break;
+                        case "MinVersion":
+                            minVersion = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "MaxVersion":
+                            maxVersion = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "MinSize":
+                            minSize = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, int.MaxValue);
+                            break;
+                        case "MaxSize":
+                            maxSize = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, int.MaxValue);
+                            break;
+                        case "MinDate":
+                            minDate = this.core.GetAttributeDateTimeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "MaxDate":
+                            maxDate = this.core.GetAttributeDateTimeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Languages":
+                            languages = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ShortName":
+                            shortName = this.core.GetAttributeShortFilename(sourceLineNumbers, attrib, false);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            // Using both ShortName and Name will not always work due to a Windows Installer bug.
+            if (null != shortName && null != name)
+            {
+                this.core.OnMessage(WixWarnings.FileSearchFileNameIssue(sourceLineNumbers, node.Name.LocalName, "ShortName", "Name"));
+            }
+            else if (null == shortName && null == name) // at least one name must be specified.
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Name"));
+            }
+
+            if (this.core.IsValidShortFilename(name, false))
+            {
+                if (null == shortName)
+                {
+                    shortName = name;
+                    name = null;
+                }
+                else
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeValueWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "Name", name, "ShortName"));
+                }
+            }
+
+            if (null == id)
+            {
+                if (String.IsNullOrEmpty(parentSignature))
+                {
+                    id = this.core.CreateIdentifier("fs", name ?? shortName);
+                }
+                else // reuse parent signature in the Signature table
+                {
+                    id = new Identifier(parentSignature, AccessModifier.Private);
+                }
+            }
+
+            bool isSameId = String.Equals(id.Id, parentSignature, StringComparison.Ordinal);
+            if (parentDirectorySearch)
+            {
+                // If searching for the parent directory, the Id attribute
+                // value must be specified and unique.
+                if (isSameId)
+                {
+                    this.core.OnMessage(WixErrors.UniqueFileSearchIdRequired(sourceLineNumbers, parentSignature, node.Name.LocalName));
+                }
+            }
+            else if (parentDepth > 1)
+            {
+                // Otherwise, if the depth > 1 the Id must be absent or the same
+                // as the parent DirectorySearch if AssignToProperty is not set.
+                if (!isSameId)
+                {
+                    this.core.OnMessage(WixErrors.IllegalSearchIdForParentDepth(sourceLineNumbers, id.Id, parentSignature));
+                }
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "Signature", id);
+                row[1] = name ?? shortName;
+                row[2] = minVersion;
+                row[3] = maxVersion;
+
+                if (CompilerConstants.IntegerNotSet != minSize)
+                {
+                    row[4] = minSize;
+                }
+                if (CompilerConstants.IntegerNotSet != maxSize)
+                {
+                    row[5] = maxSize;
+                }
+                if (CompilerConstants.IntegerNotSet != minDate)
+                {
+                    row[6] = minDate;
+                }
+                if (CompilerConstants.IntegerNotSet != maxDate)
+                {
+                    row[7] = maxDate;
+                }
+                row[8] = languages;
+
+                // Create a DrLocator row to associate the file with a directory
+                // when a different identifier is specified for the FileSearch.
+                if (!isSameId)
+                {
+                    if (parentDirectorySearch)
+                    {
+                        // Creates the DrLocator row for the directory search while
+                        // the parent DirectorySearch creates the file locator row.
+                        row = this.core.CreateRow(sourceLineNumbers, "DrLocator");
+                        row[0] = parentSignature;
+                        row[1] = id;
+                    }
+                    else
+                    {
+                        row = this.core.CreateRow(sourceLineNumbers, "DrLocator", id);
+                        row[1] = parentSignature;
+                    }
+                }
+            }
+
+            return id.Id; // the id of the FileSearch element is its signature
+        }
+
+
+        /// <summary>
+        /// Parses a fragment element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        private void ParseFragmentElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string id = null;
+
+            this.activeName = null;
+            this.activeLanguage = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            // NOTE: Id is not required for Fragments, this is a departure from the normal run of the mill processing.
+
+            this.core.CreateActiveSection(id, SectionType.Fragment, 0);
+
+            int featureDisplay = 0;
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "_locDefinition":
+                            break;
+                        case "AdminExecuteSequence":
+                            this.ParseSequenceElement(child, child.Name.LocalName);
+                            break;
+                        case "AdminUISequence":
+                            this.ParseSequenceElement(child, child.Name.LocalName);
+                            break;
+                        case "AdvertiseExecuteSequence":
+                            this.ParseSequenceElement(child, child.Name.LocalName);
+                            break;
+                        case "InstallExecuteSequence":
+                            this.ParseSequenceElement(child, child.Name.LocalName);
+                            break;
+                        case "InstallUISequence":
+                            this.ParseSequenceElement(child, child.Name.LocalName);
+                            break;
+                        case "AppId":
+                            this.ParseAppIdElement(child, null, YesNoType.Yes, null, null, null);
+                            break;
+                        case "Binary":
+                            this.ParseBinaryElement(child);
+                            break;
+                        case "BootstrapperApplication":
+                            this.ParseBootstrapperApplicationElement(child);
+                            break;
+                        case "BootstrapperApplicationRef":
+                            this.ParseBootstrapperApplicationRefElement(child);
+                            break;
+                        case "ComplianceCheck":
+                            this.ParseComplianceCheckElement(child);
+                            break;
+                        case "Component":
+                            this.ParseComponentElement(child, ComplexReferenceParentType.Unknown, null, null, CompilerConstants.IntegerNotSet, null, null);
+                            break;
+                        case "ComponentGroup":
+                            this.ParseComponentGroupElement(child, ComplexReferenceParentType.Unknown, id);
+                            break;
+                        case "Condition":
+                            this.ParseConditionElement(child, node.Name.LocalName, null, null);
+                            break;
+                        case "Container":
+                            this.ParseContainerElement(child);
+                            break;
+                        case "CustomAction":
+                            this.ParseCustomActionElement(child);
+                            break;
+                        case "CustomActionRef":
+                            this.ParseSimpleRefElement(child, "CustomAction");
+                            break;
+                        case "CustomTable":
+                            this.ParseCustomTableElement(child);
+                            break;
+                        case "Directory":
+                            this.ParseDirectoryElement(child, null, CompilerConstants.IntegerNotSet, String.Empty);
+                            break;
+                        case "DirectoryRef":
+                            this.ParseDirectoryRefElement(child);
+                            break;
+                        case "EmbeddedChainer":
+                            this.ParseEmbeddedChainerElement(child);
+                            break;
+                        case "EmbeddedChainerRef":
+                            this.ParseSimpleRefElement(child, "MsiEmbeddedChainer");
+                            break;
+                        case "EnsureTable":
+                            this.ParseEnsureTableElement(child);
+                            break;
+                        case "Feature":
+                            this.ParseFeatureElement(child, ComplexReferenceParentType.Unknown, null, ref featureDisplay);
+                            break;
+                        case "FeatureGroup":
+                            this.ParseFeatureGroupElement(child, ComplexReferenceParentType.Unknown, id);
+                            break;
+                        case "FeatureRef":
+                            this.ParseFeatureRefElement(child, ComplexReferenceParentType.Unknown, null);
+                            break;
+                        case "Icon":
+                            this.ParseIconElement(child);
+                            break;
+                        case "IgnoreModularization":
+                            this.ParseIgnoreModularizationElement(child);
+                            break;
+                        case "Media":
+                            this.ParseMediaElement(child, null);
+                            break;
+                        case "MediaTemplate":
+                            this.ParseMediaTemplateElement(child, null);
+                            break;
+                        case "PackageGroup":
+                            this.ParsePackageGroupElement(child);
+                            break;
+                        case "PackageCertificates":
+                        case "PatchCertificates":
+                            this.ParseCertificatesElement(child);
+                            break;
+                        case "PatchFamily":
+                            this.ParsePatchFamilyElement(child, ComplexReferenceParentType.Unknown, id);
+                            break;
+                        case "PatchFamilyGroup":
+                            this.ParsePatchFamilyGroupElement(child, ComplexReferenceParentType.Unknown, id);
+                            break;
+                        case "PatchFamilyGroupRef":
+                            this.ParsePatchFamilyGroupRefElement(child, ComplexReferenceParentType.Unknown, id);
+                            break;
+                        case "PayloadGroup":
+                            this.ParsePayloadGroupElement(child, ComplexReferenceParentType.Unknown, null);
+                            break;
+                        case "Property":
+                            this.ParsePropertyElement(child);
+                            break;
+                        case "PropertyRef":
+                            this.ParseSimpleRefElement(child, "Property");
+                            break;
+                        case "RelatedBundle":
+                            this.ParseRelatedBundleElement(child);
+                            break;
+                        case "SetDirectory":
+                            this.ParseSetDirectoryElement(child);
+                            break;
+                        case "SetProperty":
+                            this.ParseSetPropertyElement(child);
+                            break;
+                        case "SFPCatalog":
+                            string parentName = null;
+                            this.ParseSFPCatalogElement(child, ref parentName);
+                            break;
+                        case "UI":
+                            this.ParseUIElement(child);
+                            break;
+                        case "UIRef":
+                            this.ParseSimpleRefElement(child, "WixUI");
+                            break;
+                        case "Upgrade":
+                            this.ParseUpgradeElement(child);
+                            break;
+                        case "Variable":
+                            this.ParseVariableElement(child);
+                            break;
+                        case "WixVariable":
+                            this.ParseWixVariableElement(child);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (!this.core.EncounteredError && null != id)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "WixFragment");
+                row[0] = id;
+            }
+        }
+
+
+        /// <summary>
+        /// Parses a condition element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="parentElementLocalName">LocalName of the parent element.</param>
+        /// <param name="id">Id of the parent element.</param>
+        /// <param name="dialog">Dialog of the parent element if its a Control.</param>
+        /// <returns>The condition if one was found.</returns>
+        private string ParseConditionElement(XElement node, string parentElementLocalName, string id, string dialog)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string action = null;
+            string condition = null;
+            int level = CompilerConstants.IntegerNotSet;
+            string message = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Action":
+                            if ("Control" == parentElementLocalName)
+                            {
+                                action = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                                if (0 < action.Length)
+                                {
+                                    Wix.Condition.ActionType actionType;
+                                    if (Wix.Condition.TryParseActionType(action, out actionType))
+                                    {
+                                        action = Compiler.UppercaseFirstChar(action);
+                                    }
+                                    else
+                                    {
+                                        this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, action, "default", "disable", "enable", "hide", "show"));
+                                    }
+                                }
+                            }
+                            else
+                            {
+                                this.core.UnexpectedAttribute(node, attrib);
+                            }
+                            break;
+                        case "Level":
+                            if ("Feature" == parentElementLocalName)
+                            {
+                                level = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, short.MaxValue);
+                            }
+                            else
+                            {
+                                this.core.UnexpectedAttribute(node, attrib);
+                            }
+                            break;
+                        case "Message":
+                            if ("Fragment" == parentElementLocalName || "Product" == parentElementLocalName)
+                            {
+                                message = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            }
+                            else
+                            {
+                                this.core.UnexpectedAttribute(node, attrib);
+                            }
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            // get the condition from the inner text of the element
+            condition = this.core.GetConditionInnerText(node);
+
+            this.core.ParseForExtensionElements(node);
+
+            // the condition should not be empty
+            if (null == condition || 0 == condition.Length)
+            {
+                condition = null;
+                this.core.OnMessage(WixErrors.ConditionExpected(sourceLineNumbers, node.Name.LocalName));
+            }
+
+            switch (parentElementLocalName)
+            {
+                case "Control":
+                    if (null == action)
+                    {
+                        this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Action"));
+                    }
+
+                    if (!this.core.EncounteredError)
+                    {
+                        Row row = this.core.CreateRow(sourceLineNumbers, "ControlCondition");
+                        row[0] = dialog;
+                        row[1] = id;
+                        row[2] = action;
+                        row[3] = condition;
+                    }
+                    break;
+                case "Feature":
+                    if (CompilerConstants.IntegerNotSet == level)
+                    {
+                        this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Level"));
+                        level = CompilerConstants.IllegalInteger;
+                    }
+
+                    if (!this.core.EncounteredError)
+                    {
+                        Row row = this.core.CreateRow(sourceLineNumbers, "Condition");
+                        row[0] = id;
+                        row[1] = level;
+                        row[2] = condition;
+                    }
+                    break;
+                case "Fragment":
+                case "Product":
+                    if (null == message)
+                    {
+                        this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Message"));
+                    }
+
+                    if (!this.core.EncounteredError)
+                    {
+                        Row row = this.core.CreateRow(sourceLineNumbers, "LaunchCondition");
+                        row[0] = condition;
+                        row[1] = message;
+                    }
+                    break;
+            }
+
+            return condition;
+        }
+
+        /// <summary>
+        /// Parses a IniFile element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="componentId">Identifier of the parent component.</param>
+        private void ParseIniFileElement(XElement node, string componentId)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            int action = CompilerConstants.IntegerNotSet;
+            string directory = null;
+            string key = null;
+            string name = null;
+            string section = null;
+            string shortName = null;
+            string tableName = null;
+            string value = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Action":
+                            string actionValue = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (0 < actionValue.Length)
+                            {
+                                Wix.IniFile.ActionType actionType = Wix.IniFile.ParseActionType(actionValue);
+                                switch (actionType)
+                                {
+                                    case Wix.IniFile.ActionType.addLine:
+                                        action = MsiInterop.MsidbIniFileActionAddLine;
+                                        break;
+                                    case Wix.IniFile.ActionType.addTag:
+                                        action = MsiInterop.MsidbIniFileActionAddTag;
+                                        break;
+                                    case Wix.IniFile.ActionType.createLine:
+                                        action = MsiInterop.MsidbIniFileActionCreateLine;
+                                        break;
+                                    case Wix.IniFile.ActionType.removeLine:
+                                        action = MsiInterop.MsidbIniFileActionRemoveLine;
+                                        break;
+                                    case Wix.IniFile.ActionType.removeTag:
+                                        action = MsiInterop.MsidbIniFileActionRemoveTag;
+                                        break;
+                                    default:
+                                        this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, "Action", actionValue, "addLine", "addTag", "createLine", "removeLine", "removeTag"));
+                                        break;
+                                }
+                            }
+                            break;
+                        case "Directory":
+                            directory = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Key":
+                            key = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Name":
+                            name = this.core.GetAttributeLongFilename(sourceLineNumbers, attrib, false);
+                            break;
+                        case "Section":
+                            section = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ShortName":
+                            shortName = this.core.GetAttributeShortFilename(sourceLineNumbers, attrib, false);
+                            break;
+                        case "Value":
+                            value = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (CompilerConstants.IntegerNotSet == action)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Action"));
+                action = CompilerConstants.IllegalInteger;
+            }
+
+            if (null == key)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Key"));
+            }
+
+            if (null == name)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Name"));
+            }
+            else if (0 < name.Length)
+            {
+                if (this.core.IsValidShortFilename(name, false))
+                {
+                    if (null == shortName)
+                    {
+                        shortName = name;
+                        name = null;
+                    }
+                    else
+                    {
+                        this.core.OnMessage(WixErrors.IllegalAttributeValueWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "Name", name, "ShortName"));
+                    }
+                }
+                else // generate a short file name.
+                {
+                    if (null == shortName)
+                    {
+                        shortName = this.core.CreateShortName(name, true, false, node.Name.LocalName, componentId);
+                    }
+                }
+            }
+
+            if (null == section)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Section"));
+            }
+
+            if (null == id)
+            {
+                id = this.core.CreateIdentifier("ini", directory, name ?? shortName, section, key, name);
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (MsiInterop.MsidbIniFileActionRemoveLine == action || MsiInterop.MsidbIniFileActionRemoveTag == action)
+            {
+                tableName = "RemoveIniFile";
+            }
+            else
+            {
+                if (null == value)
+                {
+                    this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Value"));
+                }
+
+                tableName = "IniFile";
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, tableName, id);
+                row[1] = GetMsiFilenameValue(shortName, name);
+                row[2] = directory;
+                row[3] = section;
+                row[4] = key;
+                row[5] = value;
+                row[6] = action;
+                row[7] = componentId;
+            }
+        }
+
+        /// <summary>
+        /// Parses an IniFile search element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <returns>Signature for search element.</returns>
+        private string ParseIniFileSearchElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            int field = CompilerConstants.IntegerNotSet;
+            string key = null;
+            string name = null;
+            string section = null;
+            string shortName = null;
+            string signature = null;
+            int type = 1; // default is file
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Field":
+                            field = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, short.MaxValue);
+                            break;
+                        case "Key":
+                            key = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Name":
+                            name = this.core.GetAttributeLongFilename(sourceLineNumbers, attrib, false);
+                            break;
+                        case "Section":
+                            section = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ShortName":
+                            shortName = this.core.GetAttributeShortFilename(sourceLineNumbers, attrib, false);
+                            break;
+                        case "Type":
+                            string typeValue = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (0 < typeValue.Length)
+                            {
+                                Wix.IniFileSearch.TypeType typeType = Wix.IniFileSearch.ParseTypeType(typeValue);
+                                switch (typeType)
+                                {
+                                    case Wix.IniFileSearch.TypeType.directory:
+                                        type = 0;
+                                        break;
+                                    case Wix.IniFileSearch.TypeType.file:
+                                        type = 1;
+                                        break;
+                                    case Wix.IniFileSearch.TypeType.raw:
+                                        type = 2;
+                                        break;
+                                    default:
+                                        this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, "Type", typeValue, "directory", "file", "registry"));
+                                        break;
+                                }
+                            }
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == key)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Key"));
+            }
+
+            if (null == name)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Name"));
+            }
+            else if (0 < name.Length)
+            {
+                if (this.core.IsValidShortFilename(name, false))
+                {
+                    if (null == shortName)
+                    {
+                        shortName = name;
+                        name = null;
+                    }
+                    else
+                    {
+                        this.core.OnMessage(WixErrors.IllegalAttributeValueWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "Name", name, "ShortName"));
+                    }
+                }
+                else if (null == shortName) // generate a short file name.
+                {
+                    shortName = this.core.CreateShortName(name, true, false, node.Name.LocalName);
+                }
+            }
+
+            if (null == section)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Section"));
+            }
+
+            if (null == id)
+            {
+                id = this.core.CreateIdentifier("ini", name, section, key, field.ToString(), type.ToString());
+            }
+
+            signature = id.Id;
+
+            bool oneChild = false;
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    SourceLineNumber childSourceLineNumbers = Preprocessor.GetSourceLineNumbers(child);
+                    switch (child.Name.LocalName)
+                    {
+                        case "DirectorySearch":
+                            if (oneChild)
+                            {
+                                this.core.OnMessage(WixErrors.TooManySearchElements(childSourceLineNumbers, node.Name.LocalName));
+                            }
+                            oneChild = true;
+
+                            // directorysearch parentage should work like directory element, not the rest of the signature type because of the DrLocator.Parent column
+                            signature = this.ParseDirectorySearchElement(child, id.Id);
+                            break;
+                        case "DirectorySearchRef":
+                            if (oneChild)
+                            {
+                                this.core.OnMessage(WixErrors.TooManySearchElements(childSourceLineNumbers, node.Name.LocalName));
+                            }
+                            oneChild = true;
+                            signature = this.ParseDirectorySearchRefElement(child, id.Id);
+                            break;
+                        case "FileSearch":
+                            if (oneChild)
+                            {
+                                this.core.OnMessage(WixErrors.TooManySearchElements(sourceLineNumbers, node.Name.LocalName));
+                            }
+                            oneChild = true;
+                            signature = this.ParseFileSearchElement(child, id.Id, false, CompilerConstants.IntegerNotSet);
+                            id = new Identifier(signature, AccessModifier.Private); // FileSearch signatures override parent signatures
+                            break;
+                        case "FileSearchRef":
+                            if (oneChild)
+                            {
+                                this.core.OnMessage(WixErrors.TooManySearchElements(sourceLineNumbers, node.Name.LocalName));
+                            }
+                            oneChild = true;
+                            string newId = this.ParseSimpleRefElement(child, "Signature"); // FileSearch signatures override parent signatures
+                            id = new Identifier(newId, AccessModifier.Private);
+                            signature = null;
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "IniLocator", id);
+                row[1] = GetMsiFilenameValue(shortName, name);
+                row[2] = section;
+                row[3] = key;
+                if (CompilerConstants.IntegerNotSet != field)
+                {
+                    row[4] = field;
+                }
+                row[5] = type;
+            }
+
+            return signature;
+        }
+
+        /// <summary>
+        /// Parses an isolated component element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="componentId">Identifier of parent component.</param>
+        private void ParseIsolateComponentElement(XElement node, string componentId)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string shared = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Shared":
+                            shared = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.core.CreateSimpleReference(sourceLineNumbers, "Component", shared);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == shared)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Shared"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "IsolatedComponent");
+                row[0] = shared;
+                row[1] = componentId;
+            }
+        }
+
+        /// <summary>
+        /// Parses a PatchCertificates or PackageCertificates element.
+        /// </summary>
+        /// <param name="node">The element to parse.</param>
+        private void ParseCertificatesElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+
+            // no attributes are supported for this element
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    this.core.UnexpectedAttribute(node, attrib);
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "DigitalCertificate":
+                            string name = this.ParseDigitalCertificateElement(child);
+
+                            if (!this.core.EncounteredError)
+                            {
+                                Row row = this.core.CreateRow(sourceLineNumbers, "PatchCertificates" == node.Name.LocalName ? "MsiPatchCertificate" : "MsiPackageCertificate");
+                                row[0] = name;
+                                row[1] = name;
+                            }
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses an digital certificate element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <returns>The identifier of the certificate.</returns>
+        private string ParseDigitalCertificateElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            string sourceFile = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "SourceFile":
+                            sourceFile = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+                id = Identifier.Invalid;
+            }
+            else if (40 < id.Id.Length)
+            {
+                this.core.OnMessage(WixErrors.StreamNameTooLong(sourceLineNumbers, node.Name.LocalName, "Id", id.Id, id.Id.Length, 40));
+
+                // No need to check for modularization problems since DigitalSignature and thus DigitalCertificate
+                // currently have no usage in merge modules.
+            }
+
+            if (null == sourceFile)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "SourceFile"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "MsiDigitalCertificate", id);
+                row[1] = sourceFile;
+            }
+
+            return id.Id;
+        }
+
+        /// <summary>
+        /// Parses an digital signature element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="diskId">Disk id inherited from parent media.</param>
+        private void ParseDigitalSignatureElement(XElement node, string diskId)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string certificateId = null;
+            string sourceFile = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "SourceFile":
+                            sourceFile = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            // sanity check for debug to ensure the stream name will not be a problem
+            if (null != sourceFile)
+            {
+                Debug.Assert(62 >= "MsiDigitalSignature.Media.".Length + diskId.Length);
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "DigitalCertificate":
+                            certificateId = this.ParseDigitalCertificateElement(child);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (null == certificateId)
+            {
+                this.core.OnMessage(WixErrors.ExpectedElement(sourceLineNumbers, node.Name.LocalName, "DigitalCertificate"));
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "MsiDigitalSignature");
+                row[0] = "Media";
+                row[1] = diskId;
+                row[2] = certificateId;
+                row[3] = sourceFile;
+            }
+        }
+
+        /// <summary>
+        /// Parses a MajorUpgrade element.
+        /// </summary>
+        /// <param name="node">The element to parse.</param>
+        /// <param name="parentElement">The parent element.</param>
+        private void ParseMajorUpgradeElement(XElement node, IDictionary<string, string> contextValues)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            int options = MsiInterop.MsidbUpgradeAttributesMigrateFeatures;
+            bool allowDowngrades = false;
+            bool allowSameVersionUpgrades = false;
+            bool blockUpgrades = false;
+            string downgradeErrorMessage = null;
+            string disallowUpgradeErrorMessage = null;
+            string removeFeatures = null;
+            string schedule = null;
+
+            string upgradeCode = contextValues["UpgradeCode"];
+            if (String.IsNullOrEmpty(upgradeCode))
+            {
+                this.core.OnMessage(WixErrors.ParentElementAttributeRequired(sourceLineNumbers, "Product", "UpgradeCode", node.Name.LocalName));
+            }
+
+            string productVersion = contextValues["ProductVersion"];
+            if (String.IsNullOrEmpty(productVersion))
+            {
+                this.core.OnMessage(WixErrors.ParentElementAttributeRequired(sourceLineNumbers, "Product", "Version", node.Name.LocalName));
+            }
+
+            string productLanguage = contextValues["ProductLanguage"];
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "AllowDowngrades":
+                            allowDowngrades = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "AllowSameVersionUpgrades":
+                            allowSameVersionUpgrades = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Disallow":
+                            blockUpgrades = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "DowngradeErrorMessage":
+                            downgradeErrorMessage = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "DisallowUpgradeErrorMessage":
+                            disallowUpgradeErrorMessage = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "MigrateFeatures":
+                            if (YesNoType.No == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                options &= ~MsiInterop.MsidbUpgradeAttributesMigrateFeatures;
+                            }
+                            break;
+                        case "IgnoreLanguage":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                productLanguage = null;
+                            }
+                            break;
+                        case "IgnoreRemoveFailure":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                options |= MsiInterop.MsidbUpgradeAttributesIgnoreRemoveFailure;
+                            }
+                            break;
+                        case "RemoveFeatures":
+                            removeFeatures = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Schedule":
+                            schedule = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!allowDowngrades && String.IsNullOrEmpty(downgradeErrorMessage))
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "DowngradeErrorMessage", "AllowDowngrades", "yes", true));
+            }
+
+            if (allowDowngrades && !String.IsNullOrEmpty(downgradeErrorMessage))
+            {
+                this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "DowngradeErrorMessage", "AllowDowngrades", "yes"));
+            }
+
+            if (allowDowngrades && allowSameVersionUpgrades)
+            {
+                this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "AllowSameVersionUpgrades", "AllowDowngrades", "yes"));
+            }
+
+            if (blockUpgrades && String.IsNullOrEmpty(disallowUpgradeErrorMessage))
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "DisallowUpgradeErrorMessage", "Disallow", "yes", true));
+            }
+
+            if (!blockUpgrades && !String.IsNullOrEmpty(disallowUpgradeErrorMessage))
+            {
+                this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "DisallowUpgradeErrorMessage", "Disallow", "yes"));
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                // create the row that performs the upgrade (or downgrade)
+                Row row = this.core.CreateRow(sourceLineNumbers, "Upgrade");
+                row[0] = upgradeCode;
+                if (allowDowngrades)
+                {
+                    row[1] = "0"; // let any version satisfy
+                    // row[2] = maximum version; omit so we don't have to fake a version like "255.255.65535";
+                    row[3] = productLanguage;
+                    row[4] = options | MsiInterop.MsidbUpgradeAttributesVersionMinInclusive;
+                }
+                else
+                {
+                    // row[1] = minimum version; skip it so we detect all prior versions.
+                    row[2] = productVersion;
+                    row[3] = productLanguage;
+                    row[4] = allowSameVersionUpgrades ? (options | MsiInterop.MsidbUpgradeAttributesVersionMaxInclusive) : options;
+                }
+
+                row[5] = removeFeatures;
+                row[6] = Compiler.UpgradeDetectedProperty;
+
+                // Ensure the action property is secure.
+                this.AddWixPropertyRow(sourceLineNumbers, new Identifier(Compiler.UpgradeDetectedProperty, AccessModifier.Public), false, true, false);
+
+                // Add launch condition that blocks upgrades
+                if (blockUpgrades)
+                {
+                    row = this.core.CreateRow(sourceLineNumbers, "LaunchCondition");
+                    row[0] = Compiler.UpgradePreventedCondition;
+                    row[1] = disallowUpgradeErrorMessage;
+                }
+
+                // now create the Upgrade row and launch conditions to prevent downgrades (unless explicitly permitted)
+                if (!allowDowngrades)
+                {
+                    row = this.core.CreateRow(sourceLineNumbers, "Upgrade");
+                    row[0] = upgradeCode;
+                    row[1] = productVersion;
+                    // row[2] = maximum version; skip it so we detect all future versions.
+                    row[3] = productLanguage;
+                    row[4] = MsiInterop.MsidbUpgradeAttributesOnlyDetect;
+                    // row[5] = removeFeatures;
+                    row[6] = Compiler.DowngradeDetectedProperty;
+
+                    // Ensure the action property is secure.
+                    this.AddWixPropertyRow(sourceLineNumbers, new Identifier(Compiler.DowngradeDetectedProperty, AccessModifier.Public), false, true, false);
+
+                    row = this.core.CreateRow(sourceLineNumbers, "LaunchCondition");
+                    row[0] = Compiler.DowngradePreventedCondition;
+                    row[1] = downgradeErrorMessage;
+                }
+
+                // finally, schedule RemoveExistingProducts
+                row = this.core.CreateRow(sourceLineNumbers, "WixAction");
+                row[0] = "InstallExecuteSequence";
+                row[1] = "RemoveExistingProducts";
+                // row[2] = condition;
+                // row[3] = sequence;
+                row[6] = 0; // overridable
+
+                switch (schedule)
+                {
+                    case null:
+                    case "afterInstallValidate":
+                        // row[4] = beforeAction;
+                        row[5] = "InstallValidate";
+                        break;
+                    case "afterInstallInitialize":
+                        // row[4] = beforeAction;
+                        row[5] = "InstallInitialize";
+                        break;
+                    case "afterInstallExecute":
+                        // row[4] = beforeAction;
+                        row[5] = "InstallExecute";
+                        break;
+                    case "afterInstallExecuteAgain":
+                        // row[4] = beforeAction;
+                        row[5] = "InstallExecuteAgain";
+                        break;
+                    case "afterInstallFinalize":
+                        // row[4] = beforeAction;
+                        row[5] = "InstallFinalize";
+                        break;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses a media element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="patchId">Set to the PatchId if parsing Patch/Media element otherwise null.</param>
+        private void ParseMediaElement(XElement node, string patchId)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            int id = CompilerConstants.IntegerNotSet;
+            string cabinet = null;
+            CompressionLevel? compressionLevel = null;
+            string diskPrompt = null;
+            string layout = null;
+            bool patch = null != patchId;
+            string volumeLabel = null;
+            string source = null;
+            string symbols = null;
+
+            YesNoType embedCab = patch ? YesNoType.Yes : YesNoType.NotSet;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 1, short.MaxValue);
+                            break;
+                        case "Cabinet":
+                            cabinet = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "CompressionLevel":
+                            string compressionLevelString = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (0 < compressionLevelString.Length)
+                            {
+                                Wix.CompressionLevelType compressionLevelType;
+                                if (!Wix.Enums.TryParseCompressionLevelType(compressionLevelString, out compressionLevelType))
+                                {
+                                    this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, compressionLevelString, "high", "low", "medium", "mszip", "none"));
+                                }
+                                else
+                                {
+                                    compressionLevel = (CompressionLevel)Enum.Parse(typeof(CompressionLevel), compressionLevelString, true);
+                                }
+                            }
+                            break;
+                        case "DiskPrompt":
+                            diskPrompt = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            this.core.CreateSimpleReference(sourceLineNumbers, "Property", "DiskPrompt"); // ensure the output has a DiskPrompt Property defined
+                            break;
+                        case "EmbedCab":
+                            embedCab = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Layout":
+                        case "src":
+                            if (null != layout)
+                            {
+                                this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "Layout", "src"));
+                            }
+
+                            if ("src" == attrib.Name.LocalName)
+                            {
+                                this.core.OnMessage(WixWarnings.DeprecatedAttribute(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, "Layout"));
+                            }
+                            layout = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "VolumeLabel":
+                            volumeLabel = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Source":
+                            source = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (CompilerConstants.IntegerNotSet == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+                id = CompilerConstants.IllegalInteger;
+            }
+
+            if (YesNoType.IllegalValue != embedCab)
+            {
+                if (YesNoType.Yes == embedCab)
+                {
+                    if (null == cabinet)
+                    {
+                        this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Cabinet", "EmbedCab", "yes"));
+                    }
+                    else
+                    {
+                        if (62 < cabinet.Length)
+                        {
+                            this.core.OnMessage(WixErrors.MediaEmbeddedCabinetNameTooLong(sourceLineNumbers, node.Name.LocalName, "Cabinet", cabinet, cabinet.Length));
+                        }
+
+                        cabinet = String.Concat("#", cabinet);
+                    }
+                }
+                else // external cabinet file
+                {
+                    // external cabinet files must use 8.3 filenames
+                    if (!String.IsNullOrEmpty(cabinet) && !this.core.IsValidShortFilename(cabinet, false))
+                    {
+                        // WiX variables in the name will trip the "not a valid 8.3 name" switch, so let them through
+                        if (!Common.WixVariableRegex.Match(cabinet).Success)
+                        {
+                            this.core.OnMessage(WixWarnings.MediaExternalCabinetFilenameIllegal(sourceLineNumbers, node.Name.LocalName, "Cabinet", cabinet));
+                        }
+                    }
+                }
+            }
+
+            if (null != compressionLevel && null == cabinet)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Cabinet", "CompressionLevel"));
+            }
+
+            if (patch)
+            {
+                // Default Source to a form of the Patch Id if none is specified.
+                if (null == source)
+                {
+                    source = String.Concat("_", new Guid(patchId).ToString("N", CultureInfo.InvariantCulture).ToUpper(CultureInfo.InvariantCulture));
+                }
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                SourceLineNumber childSourceLineNumbers = Preprocessor.GetSourceLineNumbers(child);
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "DigitalSignature":
+                            if (YesNoType.Yes == embedCab)
+                            {
+                                this.core.OnMessage(WixErrors.SignedEmbeddedCabinet(childSourceLineNumbers));
+                            }
+                            else if (null == cabinet)
+                            {
+                                this.core.OnMessage(WixErrors.ExpectedSignedCabinetName(childSourceLineNumbers));
+                            }
+                            else
+                            {
+                                this.ParseDigitalSignatureElement(child, id.ToString(CultureInfo.InvariantCulture.NumberFormat));
+                            }
+                            break;
+                        case "PatchBaseline":
+                            if (patch)
+                            {
+                                this.ParsePatchBaselineElement(child, id);
+                            }
+                            else
+                            {
+                                this.core.UnexpectedElement(node, child);
+                            }
+                            break;
+                        case "SymbolPath":
+                            if (null != symbols)
+                            {
+                                symbols += "" + this.ParseSymbolPathElement(child);
+                            }
+                            else
+                            {
+                                symbols = this.ParseSymbolPathElement(child);
+                            }
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+
+
+            // add the row to the section
+            if (!this.core.EncounteredError)
+            {
+                MediaRow mediaRow = (MediaRow)this.core.CreateRow(sourceLineNumbers, "Media");
+                mediaRow.DiskId = id;
+                mediaRow.LastSequence = 0; // this is set in the binder
+                mediaRow.DiskPrompt = diskPrompt;
+                mediaRow.Cabinet = cabinet;
+                mediaRow.VolumeLabel = volumeLabel;
+                mediaRow.Source = source;
+
+                // the Source column is only set when creating a patch
+
+                if (null != compressionLevel || null != layout)
+                {
+                    WixMediaRow row = (WixMediaRow)this.core.CreateRow(sourceLineNumbers, "WixMedia");
+                    row.DiskId = id;
+                    row.CompressionLevel = compressionLevel;
+                    row.Layout = layout;
+                }
+
+                if (null != symbols)
+                {
+                    WixDeltaPatchSymbolPathsRow symbolRow = (WixDeltaPatchSymbolPathsRow)this.core.CreateRow(sourceLineNumbers, "WixDeltaPatchSymbolPaths");
+                    symbolRow.Id = id.ToString(CultureInfo.InvariantCulture);
+                    symbolRow.Type = SymbolPathType.Media;
+                    symbolRow.SymbolPaths = symbols;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses a media template element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="patchId">Set to the PatchId if parsing Patch/Media element otherwise null.</param>
+        private void ParseMediaTemplateElement(XElement node, string patchId)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string cabinetTemplate = "cab{0}.cab";
+            string compressionLevel = null; // this defaults to mszip in Binder
+            string diskPrompt = null;
+            bool patch = null != patchId;
+            string volumeLabel = null;
+            int maximumUncompressedMediaSize = CompilerConstants.IntegerNotSet;
+            int maximumCabinetSizeForLargeFileSplitting = CompilerConstants.IntegerNotSet;
+            Wix.CompressionLevelType compressionLevelType = Wix.CompressionLevelType.NotSet;
+
+            YesNoType embedCab = patch ? YesNoType.Yes : YesNoType.NotSet;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "CabinetTemplate":
+                            string authoredCabinetTemplateValue = this.core.GetAttributeValue(sourceLineNumbers, attrib, EmptyRule.CanBeEmpty);
+                            if (!String.IsNullOrEmpty(authoredCabinetTemplateValue))
+                            {
+                                cabinetTemplate = authoredCabinetTemplateValue;
+                            }
+
+                            // Create an example cabinet name using the maximum number of cabinets supported, 999.
+                            string exampleCabinetName = String.Format(cabinetTemplate, "###");
+                            if (!this.core.IsValidLocIdentifier(exampleCabinetName))
+                            {
+                                // The example name should not match the authored template since that would nullify the
+                                // reason for having multiple cabients. External cabinet files must also be valid file names.
+                                if (exampleCabinetName.Equals(authoredCabinetTemplateValue) || !this.core.IsValidLongFilename(exampleCabinetName, false))
+                                {
+                                    this.core.OnMessage(WixErrors.InvalidCabinetTemplate(sourceLineNumbers, cabinetTemplate));
+                                }
+                                else if (!this.core.IsValidShortFilename(exampleCabinetName, false) && !Common.WixVariableRegex.Match(exampleCabinetName).Success) // ignore short names with wix variables because it rarely works out.
+                                {
+                                    this.core.OnMessage(WixWarnings.MediaExternalCabinetFilenameIllegal(sourceLineNumbers, node.Name.LocalName, "CabinetTemplate", cabinetTemplate));
+                                }
+                            }
+                            break;
+                        case "CompressionLevel":
+                            compressionLevel = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (0 < compressionLevel.Length)
+                            {
+                                if (!Wix.Enums.TryParseCompressionLevelType(compressionLevel, out compressionLevelType))
+                                {
+                                    this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, compressionLevel, "high", "low", "medium", "mszip", "none"));
+                                }
+                            }
+                            break;
+                        case "DiskPrompt":
+                            diskPrompt = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            this.core.CreateSimpleReference(sourceLineNumbers, "Property", "DiskPrompt"); // ensure the output has a DiskPrompt Property defined
+                            this.core.OnMessage(WixWarnings.ReservedAttribute(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName));
+                            break;
+                        case "EmbedCab":
+                            embedCab = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "VolumeLabel":
+                            volumeLabel = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            this.core.OnMessage(WixWarnings.ReservedAttribute(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName));
+                            break;
+                        case "MaximumUncompressedMediaSize":
+                            maximumUncompressedMediaSize = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 1, int.MaxValue);
+                            break;
+                        case "MaximumCabinetSizeForLargeFileSplitting":
+                            maximumCabinetSizeForLargeFileSplitting = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, CompilerCore.MinValueOfMaxCabSizeForLargeFileSplitting, CompilerCore.MaxValueOfMaxCabSizeForLargeFileSplitting);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (YesNoType.IllegalValue != embedCab)
+            {
+                if (YesNoType.Yes == embedCab)
+                {
+                    cabinetTemplate = String.Concat("#", cabinetTemplate);
+                }
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                MediaRow temporaryMediaRow = (MediaRow)this.core.CreateRow(sourceLineNumbers, "Media");
+                temporaryMediaRow.DiskId = 1;
+                WixMediaTemplateRow mediaTemplateRow = (WixMediaTemplateRow)this.core.CreateRow(sourceLineNumbers, "WixMediaTemplate");
+                mediaTemplateRow.CabinetTemplate = cabinetTemplate;
+                mediaTemplateRow.VolumeLabel = volumeLabel;
+                mediaTemplateRow.DiskPrompt = diskPrompt;
+                mediaTemplateRow.VolumeLabel = volumeLabel;
+
+                if (maximumUncompressedMediaSize != CompilerConstants.IntegerNotSet)
+                {
+                    mediaTemplateRow.MaximumUncompressedMediaSize = maximumUncompressedMediaSize;
+                }
+                else
+                {
+                    mediaTemplateRow.MaximumUncompressedMediaSize = CompilerCore.DefaultMaximumUncompressedMediaSize;
+                }
+
+                if (maximumCabinetSizeForLargeFileSplitting != CompilerConstants.IntegerNotSet)
+                {
+                    mediaTemplateRow.MaximumCabinetSizeForLargeFileSplitting = maximumCabinetSizeForLargeFileSplitting;
+                }
+                else
+                {
+                    mediaTemplateRow.MaximumCabinetSizeForLargeFileSplitting = 0; // Default value of 0 corresponds to max size of 2048 MB (i.e. 2 GB)
+                }
+
+                switch (compressionLevelType)
+                {
+                    case Wix.CompressionLevelType.high:
+                        mediaTemplateRow.CompressionLevel = CompressionLevel.High;
+                        break;
+                    case Wix.CompressionLevelType.low:
+                        mediaTemplateRow.CompressionLevel = CompressionLevel.Low;
+                        break;
+                    case Wix.CompressionLevelType.medium:
+                        mediaTemplateRow.CompressionLevel = CompressionLevel.Medium;
+                        break;
+                    case Wix.CompressionLevelType.none:
+                        mediaTemplateRow.CompressionLevel = CompressionLevel.None;
+                        break;
+                    case Wix.CompressionLevelType.mszip:
+                        mediaTemplateRow.CompressionLevel = CompressionLevel.Mszip;
+                        break;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses a merge element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="directoryId">Identifier for parent directory.</param>
+        /// <param name="diskId">Disk id inherited from parent directory.</param>
+        private void ParseMergeElement(XElement node, string directoryId, int diskId)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            string configData = String.Empty;
+            YesNoType fileCompression = YesNoType.NotSet;
+            string language = null;
+            string sourceFile = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "DiskId":
+                            diskId = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 1, short.MaxValue);
+                            this.core.CreateSimpleReference(sourceLineNumbers, "Media", diskId.ToString(CultureInfo.InvariantCulture.NumberFormat));
+                            break;
+                        case "FileCompression":
+                            fileCompression = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Language":
+                            language = this.core.GetAttributeLocalizableIntegerValue(sourceLineNumbers, attrib, 0, short.MaxValue);
+                            break;
+                        case "SourceFile":
+                            sourceFile = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            if (null == language)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Language"));
+            }
+
+            if (null == sourceFile)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "SourceFile"));
+            }
+
+            if (CompilerConstants.IntegerNotSet == diskId)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttributeInElementOrParent(sourceLineNumbers, node.Name.LocalName, "DiskId", "Directory"));
+                diskId = CompilerConstants.IllegalInteger;
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "ConfigurationData":
+                            if (0 == configData.Length)
+                            {
+                                configData = this.ParseConfigurationDataElement(child);
+                            }
+                            else
+                            {
+                                configData = String.Concat(configData, ",", this.ParseConfigurationDataElement(child));
+                            }
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "WixMerge", id);
+                row[1] = language;
+                row[2] = directoryId;
+                row[3] = sourceFile;
+                row[4] = diskId;
+                if (YesNoType.Yes == fileCompression)
+                {
+                    row[5] = 1;
+                }
+                else if (YesNoType.No == fileCompression)
+                {
+                    row[5] = 0;
+                }
+                else // YesNoType.NotSet == fileCompression
+                {
+                    // and we leave the column null
+                }
+                row[6] = configData;
+                row[7] = Guid.Empty.ToString("B");
+            }
+        }
+
+        /// <summary>
+        /// Parses a configuration data element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <returns>String in format "name=value" with '%', ',' and '=' hex encoded.</returns>
+        private string ParseConfigurationDataElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string name = null;
+            string value = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Name":
+                            name = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Value":
+                            value = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == name)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Name"));
+            }
+            else // need to hex encode these characters
+            {
+                name = name.Replace("%", "%25");
+                name = name.Replace("=", "%3D");
+                name = name.Replace(",", "%2C");
+            }
+
+            if (null == value)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Value"));
+            }
+            else // need to hex encode these characters
+            {
+                value = value.Replace("%", "%25");
+                value = value.Replace("=", "%3D");
+                value = value.Replace(",", "%2C");
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            return String.Concat(name, "=", value);
+        }
+
+        /// <summary>
+        /// Parses a merge reference element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="parentType">Parents complex reference type.</param>
+        /// <param name="parentId">Identifier for parent feature or feature group.</param>
+        private void ParseMergeRefElement(XElement node, ComplexReferenceParentType parentType, string parentId)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string id = null;
+            YesNoType primary = YesNoType.NotSet;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.core.CreateSimpleReference(sourceLineNumbers, "WixMerge", id);
+                            break;
+                        case "Primary":
+                            primary = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            this.core.CreateComplexReference(sourceLineNumbers, parentType, parentId, null, ComplexReferenceChildType.Module, id, (YesNoType.Yes == primary));
+        }
+
+        /// <summary>
+        /// Parses a mime element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="extension">Identifier for parent extension.</param>
+        /// <param name="componentId">Identifier for parent component.</param>
+        /// <param name="parentAdvertised">Flag if the parent element is advertised.</param>
+        /// <returns>Content type if this is the default for the MIME type.</returns>
+        private string ParseMIMEElement(XElement node, string extension, string componentId, YesNoType parentAdvertised)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string classId = null;
+            string contentType = null;
+            YesNoType advertise = parentAdvertised;
+            YesNoType returnContentType = YesNoType.NotSet;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Advertise":
+                            advertise = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Class":
+                            classId = this.core.GetAttributeGuidValue(sourceLineNumbers, attrib, false);
+                            break;
+                        case "ContentType":
+                            contentType = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Default":
+                            returnContentType = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == contentType)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "ContentType"));
+            }
+
+            // if the advertise state has not been set, default to non-advertised
+            if (YesNoType.NotSet == advertise)
+            {
+                advertise = YesNoType.No;
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (YesNoType.Yes == advertise)
+            {
+                if (YesNoType.Yes != parentAdvertised)
+                {
+                    this.core.OnMessage(WixErrors.AdvertiseStateMustMatch(sourceLineNumbers, advertise.ToString(), parentAdvertised.ToString()));
+                }
+
+                if (!this.core.EncounteredError)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "MIME");
+                    row[0] = contentType;
+                    row[1] = extension;
+                    row[2] = classId;
+                }
+            }
+            else if (YesNoType.No == advertise)
+            {
+                if (YesNoType.Yes == returnContentType && YesNoType.Yes == parentAdvertised)
+                {
+                    this.core.OnMessage(WixErrors.CannotDefaultMismatchedAdvertiseStates(sourceLineNumbers));
+                }
+
+                this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("MIME\\Database\\Content Type\\", contentType), "Extension", String.Concat(".", extension), componentId);
+                if (null != classId)
+                {
+                    this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("MIME\\Database\\Content Type\\", contentType), "CLSID", classId, componentId);
+                }
+            }
+
+            return YesNoType.Yes == returnContentType ? contentType : null;
+        }
+
+        /// <summary>
+        /// Parses a module element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        private void ParseModuleElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            int codepage = 0;
+            string moduleId = null;
+            string version = null;
+
+            this.activeName = null;
+            this.activeLanguage = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            this.activeName = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if ("PUT-MODULE-NAME-HERE" == this.activeName)
+                            {
+                                this.core.OnMessage(WixWarnings.PlaceholderValue(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, this.activeName));
+                            }
+                            else
+                            {
+                                this.activeName = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            }
+                            break;
+                        case "Codepage":
+                            codepage = this.core.GetAttributeCodePageValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Guid":
+                            moduleId = this.core.GetAttributeGuidValue(sourceLineNumbers, attrib, false);
+                            this.core.OnMessage(WixWarnings.DeprecatedModuleGuidAttribute(sourceLineNumbers));
+                            break;
+                        case "Language":
+                            this.activeLanguage = this.core.GetAttributeLocalizableIntegerValue(sourceLineNumbers, attrib, 0, short.MaxValue);
+                            break;
+                        case "Version":
+                            version = this.core.GetAttributeVersionValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == this.activeName)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            if (null == this.activeLanguage)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Language"));
+            }
+
+            if (null == version)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Version"));
+            }
+            else if (!CompilerCore.IsValidModuleOrBundleVersion(version))
+            {
+                this.core.OnMessage(WixWarnings.InvalidModuleOrBundleVersion(sourceLineNumbers, "Module", version));
+            }
+
+            try
+            {
+                this.compilingModule = true; // notice that we are actually building a Merge Module here
+                this.core.CreateActiveSection(this.activeName, SectionType.Module, codepage);
+
+                foreach (XElement child in node.Elements())
+                {
+                    if (CompilerCore.WixNamespace == child.Name.Namespace)
+                    {
+                        switch (child.Name.LocalName)
+                        {
+                            case "AdminExecuteSequence":
+                            case "AdminUISequence":
+                            case "AdvertiseExecuteSequence":
+                            case "InstallExecuteSequence":
+                            case "InstallUISequence":
+                                this.ParseSequenceElement(child, child.Name.LocalName);
+                                break;
+                            case "AppId":
+                                this.ParseAppIdElement(child, null, YesNoType.Yes, null, null, null);
+                                break;
+                            case "Binary":
+                                this.ParseBinaryElement(child);
+                                break;
+                            case "Component":
+                                this.ParseComponentElement(child, ComplexReferenceParentType.Module, this.activeName, this.activeLanguage, CompilerConstants.IntegerNotSet, null, null);
+                                break;
+                            case "ComponentGroupRef":
+                                this.ParseComponentGroupRefElement(child, ComplexReferenceParentType.Module, this.activeName, this.activeLanguage);
+                                break;
+                            case "ComponentRef":
+                                this.ParseComponentRefElement(child, ComplexReferenceParentType.Module, this.activeName, this.activeLanguage);
+                                break;
+                            case "Configuration":
+                                this.ParseConfigurationElement(child);
+                                break;
+                            case "CustomAction":
+                                this.ParseCustomActionElement(child);
+                                break;
+                            case "CustomActionRef":
+                                this.ParseSimpleRefElement(child, "CustomAction");
+                                break;
+                            case "CustomTable":
+                                this.ParseCustomTableElement(child);
+                                break;
+                            case "Dependency":
+                                this.ParseDependencyElement(child);
+                                break;
+                            case "Directory":
+                                this.ParseDirectoryElement(child, null, CompilerConstants.IntegerNotSet, String.Empty);
+                                break;
+                            case "DirectoryRef":
+                                this.ParseDirectoryRefElement(child);
+                                break;
+                            case "EmbeddedChainer":
+                                this.ParseEmbeddedChainerElement(child);
+                                break;
+                            case "EmbeddedChainerRef":
+                                this.ParseSimpleRefElement(child, "MsiEmbeddedChainer");
+                                break;
+                            case "EnsureTable":
+                                this.ParseEnsureTableElement(child);
+                                break;
+                            case "Exclusion":
+                                this.ParseExclusionElement(child);
+                                break;
+                            case "Icon":
+                                this.ParseIconElement(child);
+                                break;
+                            case "IgnoreModularization":
+                                this.ParseIgnoreModularizationElement(child);
+                                break;
+                            case "IgnoreTable":
+                                this.ParseIgnoreTableElement(child);
+                                break;
+                            case "Package":
+                                this.ParsePackageElement(child, null, moduleId);
+                                break;
+                            case "Property":
+                                this.ParsePropertyElement(child);
+                                break;
+                            case "PropertyRef":
+                                this.ParseSimpleRefElement(child, "Property");
+                                break;
+                            case "SetDirectory":
+                                this.ParseSetDirectoryElement(child);
+                                break;
+                            case "SetProperty":
+                                this.ParseSetPropertyElement(child);
+                                break;
+                            case "SFPCatalog":
+                                string parentName = null;
+                                this.ParseSFPCatalogElement(child, ref parentName);
+                                break;
+                            case "Substitution":
+                                this.ParseSubstitutionElement(child);
+                                break;
+                            case "UI":
+                                this.ParseUIElement(child);
+                                break;
+                            case "UIRef":
+                                this.ParseSimpleRefElement(child, "WixUI");
+                                break;
+                            case "WixVariable":
+                                this.ParseWixVariableElement(child);
+                                break;
+                            default:
+                                this.core.UnexpectedElement(node, child);
+                                break;
+                        }
+                    }
+                    else
+                    {
+                        this.core.ParseExtensionElement(node, child);
+                    }
+                }
+
+
+                if (!this.core.EncounteredError)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "ModuleSignature");
+                    row[0] = this.activeName;
+                    row[1] = this.activeLanguage;
+                    row[2] = version;
+                }
+            }
+            finally
+            {
+                this.compilingModule = false; // notice that we are no longer building a Merge Module here
+            }
+        }
+
+        /// <summary>
+        /// Parses a patch creation element.
+        /// </summary>
+        /// <param name="node">The element to parse.</param>
+        private void ParsePatchCreationElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            bool clean = true; // Default is to clean
+            int codepage = 0;
+            string outputPath = null;
+            bool productMismatches = false;
+            string replaceGuids = String.Empty;
+            string sourceList = null;
+            string symbolFlags = null;
+            string targetProducts = String.Empty;
+            bool versionMismatches = false;
+            bool wholeFiles = false;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            this.activeName = this.core.GetAttributeGuidValue(sourceLineNumbers, attrib, false);
+                            break;
+                        case "AllowMajorVersionMismatches":
+                            versionMismatches = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "AllowProductCodeMismatches":
+                            productMismatches = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "CleanWorkingFolder":
+                            clean = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Codepage":
+                            codepage = this.core.GetAttributeCodePageValue(sourceLineNumbers, attrib);
+                            break;
+                        case "OutputPath":
+                            outputPath = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "SourceList":
+                            sourceList = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "SymbolFlags":
+                            symbolFlags = String.Format(CultureInfo.InvariantCulture, "0x{0:x8}", this.core.GetAttributeLongValue(sourceLineNumbers, attrib, 0, uint.MaxValue));
+                            break;
+                        case "WholeFilesOnly":
+                            wholeFiles = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == this.activeName)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            this.core.CreateActiveSection(this.activeName, SectionType.PatchCreation, codepage);
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "Family":
+                            this.ParseFamilyElement(child);
+                            break;
+                        case "PatchInformation":
+                            this.ParsePatchInformationElement(child);
+                            break;
+                        case "PatchMetadata":
+                            this.ParsePatchMetadataElement(child);
+                            break;
+                        case "PatchProperty":
+                            this.ParsePatchPropertyElement(child, false);
+                            break;
+                        case "PatchSequence":
+                            this.ParsePatchSequenceElement(child);
+                            break;
+                        case "ReplacePatch":
+                            replaceGuids = String.Concat(replaceGuids, this.ParseReplacePatchElement(child));
+                            break;
+                        case "TargetProductCode":
+                            string targetProduct = this.ParseTargetProductCodeElement(child);
+                            if (0 < targetProducts.Length)
+                            {
+                                targetProducts = String.Concat(targetProducts, ";");
+                            }
+                            targetProducts = String.Concat(targetProducts, targetProduct);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            this.ProcessProperties(sourceLineNumbers, "PatchGUID", this.activeName);
+            this.ProcessProperties(sourceLineNumbers, "AllowProductCodeMismatches", productMismatches ? "1" : "0");
+            this.ProcessProperties(sourceLineNumbers, "AllowProductVersionMajorMismatches", versionMismatches ? "1" : "0");
+            this.ProcessProperties(sourceLineNumbers, "DontRemoveTempFolderWhenFinished", clean ? "0" : "1");
+            this.ProcessProperties(sourceLineNumbers, "IncludeWholeFilesOnly", wholeFiles ? "1" : "0");
+
+            if (null != symbolFlags)
+            {
+                this.ProcessProperties(sourceLineNumbers, "ApiPatchingSymbolFlags", symbolFlags);
+            }
+
+            if (0 < replaceGuids.Length)
+            {
+                this.ProcessProperties(sourceLineNumbers, "ListOfPatchGUIDsToReplace", replaceGuids);
+            }
+
+            if (0 < targetProducts.Length)
+            {
+                this.ProcessProperties(sourceLineNumbers, "ListOfTargetProductCodes", targetProducts);
+            }
+
+            if (null != outputPath)
+            {
+                this.ProcessProperties(sourceLineNumbers, "PatchOutputPath", outputPath);
+            }
+
+            if (null != sourceList)
+            {
+                this.ProcessProperties(sourceLineNumbers, "PatchSourceList", sourceList);
+            }
+        }
+
+        /// <summary>
+        /// Parses a family element.
+        /// </summary>
+        /// <param name="node">The element to parse.</param>
+        private void ParseFamilyElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            int diskId = CompilerConstants.IntegerNotSet;
+            string diskPrompt = null;
+            string mediaSrcProp = null;
+            string name = null;
+            int sequenceStart = CompilerConstants.IntegerNotSet;
+            string volumeLabel = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "DiskId":
+                            diskId = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 1, short.MaxValue);
+                            break;
+                        case "DiskPrompt":
+                            diskPrompt = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "MediaSrcProp":
+                            mediaSrcProp = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Name":
+                            name = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "SequenceStart":
+                            sequenceStart = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 1, int.MaxValue);
+                            break;
+                        case "VolumeLabel":
+                            volumeLabel = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == name)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Name"));
+            }
+            else if (0 < name.Length)
+            {
+                if (8 < name.Length) // check the length
+                {
+                    this.core.OnMessage(WixErrors.FamilyNameTooLong(sourceLineNumbers, node.Name.LocalName, "Name", name, name.Length));
+                }
+                else // check for illegal characters
+                {
+                    foreach (char character in name)
+                    {
+                        if (!Char.IsLetterOrDigit(character) && '_' != character)
+                        {
+                            this.core.OnMessage(WixErrors.IllegalFamilyName(sourceLineNumbers, node.Name.LocalName, "Name", name));
+                        }
+                    }
+                }
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "UpgradeImage":
+                            this.ParseUpgradeImageElement(child, name);
+                            break;
+                        case "ExternalFile":
+                            this.ParseExternalFileElement(child, name);
+                            break;
+                        case "ProtectFile":
+                            this.ParseProtectFileElement(child, name);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "ImageFamilies");
+                row[0] = name;
+                row[1] = mediaSrcProp;
+                if (CompilerConstants.IntegerNotSet != diskId)
+                {
+                    row[2] = diskId;
+                }
+
+                if (CompilerConstants.IntegerNotSet != sequenceStart)
+                {
+                    row[3] = sequenceStart;
+                }
+                row[4] = diskPrompt;
+                row[5] = volumeLabel;
+            }
+        }
+
+        /// <summary>
+        /// Parses an upgrade image element.
+        /// </summary>
+        /// <param name="node">The element to parse.</param>
+        /// <param name="family">The family for this element.</param>
+        private void ParseUpgradeImageElement(XElement node, string family)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string sourceFile = null;
+            string sourcePatch = null;
+            List<string> symbols = new List<string>();
+            string upgrade = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            upgrade = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (13 < upgrade.Length)
+                            {
+                                this.core.OnMessage(WixErrors.IdentifierTooLongError(sourceLineNumbers, node.Name.LocalName, "Id", upgrade, 13));
+                            }
+                            break;
+                        case "SourceFile":
+                        case "src":
+                            if (null != sourceFile)
+                            {
+                                this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "src", "SourceFile"));
+                            }
+
+                            if ("src" == attrib.Name.LocalName)
+                            {
+                                this.core.OnMessage(WixWarnings.DeprecatedAttribute(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, "SourceFile"));
+                            }
+                            sourceFile = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "SourcePatch":
+                        case "srcPatch":
+                            if (null != sourcePatch)
+                            {
+                                this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "srcPatch", "SourcePatch"));
+                            }
+
+                            if ("srcPatch" == attrib.Name.LocalName)
+                            {
+                                this.core.OnMessage(WixWarnings.DeprecatedAttribute(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, "SourcePatch"));
+                            }
+                            sourcePatch = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == upgrade)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            if (null == sourceFile)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "SourceFile"));
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "SymbolPath":
+                            symbols.Add(this.ParseSymbolPathElement(child));
+                            break;
+                        case "TargetImage":
+                            this.ParseTargetImageElement(child, upgrade, family);
+                            break;
+                        case "UpgradeFile":
+                            this.ParseUpgradeFileElement(child, upgrade);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "UpgradedImages");
+                row[0] = upgrade;
+                row[1] = sourceFile;
+                row[2] = sourcePatch;
+                row[3] = String.Join(";", symbols);
+                row[4] = family;
+            }
+        }
+
+        /// <summary>
+        /// Parses an upgrade file element.
+        /// </summary>
+        /// <param name="node">The element to parse.</param>
+        /// <param name="upgrade">The upgrade key for this element.</param>
+        private void ParseUpgradeFileElement(XElement node, string upgrade)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            bool allowIgnoreOnError = false;
+            string file = null;
+            bool ignore = false;
+            List<string> symbols = new List<string>();
+            bool wholeFile = false;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "AllowIgnoreOnError":
+                            allowIgnoreOnError = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "File":
+                            file = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Ignore":
+                            ignore = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "WholeFile":
+                            wholeFile = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == file)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "File"));
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "SymbolPath":
+                            symbols.Add(this.ParseSymbolPathElement(child));
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                if (ignore)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "UpgradedFilesToIgnore");
+                    row[0] = upgrade;
+                    row[1] = file;
+                }
+                else
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "UpgradedFiles_OptionalData");
+                    row[0] = upgrade;
+                    row[1] = file;
+                    row[2] = String.Join(";", symbols);
+                    row[3] = allowIgnoreOnError ? 1 : 0;
+                    row[4] = wholeFile ? 1 : 0;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses a target image element.
+        /// </summary>
+        /// <param name="node">The element to parse.</param>
+        /// <param name="upgrade">The upgrade key for this element.</param>
+        /// <param name="family">The family key for this element.</param>
+        private void ParseTargetImageElement(XElement node, string upgrade, string family)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            bool ignore = false;
+            int order = CompilerConstants.IntegerNotSet;
+            string sourceFile = null;
+            string symbols = null;
+            string target = null;
+            string validation = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            target = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (target.Length > 13)
+                            {
+                                this.core.OnMessage(WixErrors.IdentifierTooLongError(sourceLineNumbers, node.Name.LocalName, "Id", target, 13));
+                            }
+                            break;
+                        case "IgnoreMissingFiles":
+                            ignore = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Order":
+                            order = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, int.MinValue + 2, int.MaxValue);
+                            break;
+                        case "SourceFile":
+                        case "src":
+                            if (null != sourceFile)
+                            {
+                                this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "src", "SourceFile"));
+                            }
+
+                            if ("src" == attrib.Name.LocalName)
+                            {
+                                this.core.OnMessage(WixWarnings.DeprecatedAttribute(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, "SourceFile"));
+                            }
+                            sourceFile = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Validation":
+                            validation = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == target)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            if (null == sourceFile)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "SourceFile"));
+            }
+
+            if (CompilerConstants.IntegerNotSet == order)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Order"));
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "SymbolPath":
+                            if (null != symbols)
+                            {
+                                symbols = String.Concat(symbols, ";", this.ParseSymbolPathElement(child));
+                            }
+                            else
+                            {
+                                symbols = this.ParseSymbolPathElement(child);
+                            }
+                            break;
+                        case "TargetFile":
+                            this.ParseTargetFileElement(child, target, family);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "TargetImages");
+                row[0] = target;
+                row[1] = sourceFile;
+                row[2] = symbols;
+                row[3] = upgrade;
+                row[4] = order;
+                row[5] = validation;
+                row[6] = ignore ? 1 : 0;
+            }
+        }
+
+        /// <summary>
+        /// Parses an upgrade file element.
+        /// </summary>
+        /// <param name="node">The element to parse.</param>
+        /// <param name="target">The upgrade key for this element.</param>
+        /// <param name="family">The family key for this element.</param>
+        private void ParseTargetFileElement(XElement node, string target, string family)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string file = null;
+            string ignoreLengths = null;
+            string ignoreOffsets = null;
+            string protectLengths = null;
+            string protectOffsets = null;
+            string symbols = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            file = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == file)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "IgnoreRange":
+                            this.ParseRangeElement(child, ref ignoreOffsets, ref ignoreLengths);
+                            break;
+                        case "ProtectRange":
+                            this.ParseRangeElement(child, ref protectOffsets, ref protectLengths);
+                            break;
+                        case "SymbolPath":
+                            symbols = this.ParseSymbolPathElement(child);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "TargetFiles_OptionalData");
+                row[0] = target;
+                row[1] = file;
+                row[2] = symbols;
+                row[3] = ignoreOffsets;
+                row[4] = ignoreLengths;
+
+                if (null != protectOffsets)
+                {
+                    row[5] = protectOffsets;
+
+                    Row row2 = this.core.CreateRow(sourceLineNumbers, "FamilyFileRanges");
+                    row2[0] = family;
+                    row2[1] = file;
+                    row2[2] = protectOffsets;
+                    row2[3] = protectLengths;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses an external file element.
+        /// </summary>
+        /// <param name="node">The element to parse.</param>
+        /// <param name="family">The family for this element.</param>
+        private void ParseExternalFileElement(XElement node, string family)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string file = null;
+            string ignoreLengths = null;
+            string ignoreOffsets = null;
+            int order = CompilerConstants.IntegerNotSet;
+            string protectLengths = null;
+            string protectOffsets = null;
+            string source = null;
+            string symbols = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "File":
+                            file = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Order":
+                            order = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, int.MinValue + 2, int.MaxValue);
+                            break;
+                        case "Source":
+                        case "src":
+                            if (null != source)
+                            {
+                                this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "src", "Source"));
+                            }
+
+                            if ("src" == attrib.Name.LocalName)
+                            {
+                                this.core.OnMessage(WixWarnings.DeprecatedAttribute(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, "Source"));
+                            }
+                            source = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == file)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "File"));
+            }
+
+            if (null == source)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Source"));
+            }
+
+            if (CompilerConstants.IntegerNotSet == order)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Order"));
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "IgnoreRange":
+                            this.ParseRangeElement(child, ref ignoreOffsets, ref ignoreLengths);
+                            break;
+                        case "ProtectRange":
+                            this.ParseRangeElement(child, ref protectOffsets, ref protectLengths);
+                            break;
+                        case "SymbolPath":
+                            symbols = this.ParseSymbolPathElement(child);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "ExternalFiles");
+                row[0] = family;
+                row[1] = file;
+                row[2] = source;
+                row[3] = symbols;
+                row[4] = ignoreOffsets;
+                row[5] = ignoreLengths;
+                if (null != protectOffsets)
+                {
+                    row[6] = protectOffsets;
+                }
+
+                if (CompilerConstants.IntegerNotSet != order)
+                {
+                    row[7] = order;
+                }
+
+                if (null != protectOffsets)
+                {
+                    Row row2 = this.core.CreateRow(sourceLineNumbers, "FamilyFileRanges");
+                    row2[0] = family;
+                    row2[1] = file;
+                    row2[2] = protectOffsets;
+                    row2[3] = protectLengths;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses a protect file element.
+        /// </summary>
+        /// <param name="node">The element to parse.</param>
+        /// <param name="family">The family for this element.</param>
+        private void ParseProtectFileElement(XElement node, string family)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string file = null;
+            string protectLengths = null;
+            string protectOffsets = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "File":
+                            file = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == file)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "File"));
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "ProtectRange":
+                            this.ParseRangeElement(child, ref protectOffsets, ref protectLengths);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (null == protectOffsets || null == protectLengths)
+            {
+                this.core.OnMessage(WixErrors.ExpectedElement(sourceLineNumbers, node.Name.LocalName, "ProtectRange"));
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "FamilyFileRanges");
+                row[0] = family;
+                row[1] = file;
+                row[2] = protectOffsets;
+                row[3] = protectLengths;
+            }
+        }
+
+        /// <summary>
+        /// Parses a range element (ProtectRange, IgnoreRange, etc).
+        /// </summary>
+        /// <param name="node">The element to parse.</param>
+        /// <param name="offsets">Reference to the offsets string.</param>
+        /// <param name="lengths">Reference to the lengths string.</param>
+        private void ParseRangeElement(XElement node, ref string offsets, ref string lengths)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string length = null;
+            string offset = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Length":
+                            length = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Offset":
+                            offset = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == length)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Length"));
+            }
+
+            if (null == offset)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Offset"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (null != lengths)
+            {
+                lengths = String.Concat(lengths, ",", length);
+            }
+            else
+            {
+                lengths = length;
+            }
+
+            if (null != offsets)
+            {
+                offsets = String.Concat(offsets, ",", offset);
+            }
+            else
+            {
+                offsets = offset;
+            }
+        }
+
+        /// <summary>
+        /// Parses a patch property element.
+        /// </summary>
+        /// <param name="node">The element to parse.</param>
+        /// <param name="patch">True if parsing an patch element.</param>
+        private void ParsePatchPropertyElement(XElement node, bool patch)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string name = null;
+            string company = null;
+            string value = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                        case "Name":
+                            name = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Company":
+                            company = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Value":
+                            value = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == name)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Name"));
+            }
+
+            if (null == value)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Value"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (patch)
+            {
+                // /Patch/PatchProperty goes directly into MsiPatchMetadata table
+                Row row = this.core.CreateRow(sourceLineNumbers, "MsiPatchMetadata");
+                row[0] = company;
+                row[1] = name;
+                row[2] = value;
+            }
+            else
+            {
+                if (null != company)
+                {
+                    this.core.OnMessage(WixErrors.UnexpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Company"));
+                }
+                this.ProcessProperties(sourceLineNumbers, name, value);
+            }
+        }
+
+        /// <summary>
+        /// Parses a patch sequence element.
+        /// </summary>
+        /// <param name="node">The element to parse.</param>
+        private void ParsePatchSequenceElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string family = null;
+            string target = null;
+            string sequence = null;
+            int attributes = 0;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "PatchFamily":
+                            family = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ProductCode":
+                            if (null != target)
+                            {
+                                this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttributes(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, "Target", "TargetImage"));
+                            }
+                            target = this.core.GetAttributeGuidValue(sourceLineNumbers, attrib, false);
+                            break;
+                        case "Target":
+                            if (null != target)
+                            {
+                                this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttributes(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, "TargetImage", "ProductCode"));
+                            }
+                            this.core.OnMessage(WixWarnings.DeprecatedPatchSequenceTargetAttribute(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName));
+                            target = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "TargetImage":
+                            if (null != target)
+                            {
+                                this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttributes(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, "Target", "ProductCode"));
+                            }
+                            target = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            this.core.CreateSimpleReference(sourceLineNumbers, "TargetImages", target);
+                            break;
+                        case "Sequence":
+                            sequence = this.core.GetAttributeVersionValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Supersede":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= 0x1;
+                            }
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == family)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "PatchFamily"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "PatchSequence");
+                row[0] = family;
+                row[1] = target;
+                if (!String.IsNullOrEmpty(sequence))
+                {
+                    row[2] = sequence;
+                }
+                row[3] = attributes;
+            }
+        }
+
+        /// <summary>
+        /// Parses a TargetProductCode element.
+        /// </summary>
+        /// <param name="node">The element to parse.</param>
+        /// <returns>The id from the node.</returns>
+        private string ParseTargetProductCodeElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string id = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (id.Length > 0 && "*" != id)
+                            {
+                                id = this.core.GetAttributeGuidValue(sourceLineNumbers, attrib, false);
+                            }
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            return id;
+        }
+
+        /// <summary>
+        /// Parses a TargetProductCodes element.
+        /// </summary>
+        /// <param name="node">The element to parse.</param>
+        private void ParseTargetProductCodesElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            bool replace = false;
+            List<string> targetProductCodes = new List<string>();
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Replace":
+                            replace = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "TargetProductCode":
+                            string id = this.ParseTargetProductCodeElement(child);
+                            if (0 == String.CompareOrdinal("*", id))
+                            {
+                                this.core.OnMessage(WixErrors.IllegalAttributeValueWhenNested(sourceLineNumbers, child.Name.LocalName, "Id", id, node.Name.LocalName));
+                            }
+                            else
+                            {
+                                targetProductCodes.Add(id);
+                            }
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                // By default, target ProductCodes should be added.
+                if (!replace)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "WixPatchTarget");
+                    row[0] = "*";
+                }
+
+                foreach (string targetProductCode in targetProductCodes)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "WixPatchTarget");
+                    row[0] = targetProductCode;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses a ReplacePatch element.
+        /// </summary>
+        /// <param name="node">The element to parse.</param>
+        /// <returns>The id from the node.</returns>
+        private string ParseReplacePatchElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string id = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeGuidValue(sourceLineNumbers, attrib, false);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            return id;
+        }
+
+        /// <summary>
+        /// Parses a symbol path element.
+        /// </summary>
+        /// <param name="node">The element to parse.</param>
+        /// <returns>The path from the node.</returns>
+        private string ParseSymbolPathElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string path = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Path":
+                            path = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == path)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Path"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            return path;
+        }
+
+        /// <summary>
+        /// Parses an patch element.
+        /// </summary>
+        /// <param name="node">The element to parse.</param>
+        private void ParsePatchElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string patchId = null;
+            int codepage = 0;
+            ////bool versionMismatches = false;
+            ////bool productMismatches = false;
+            bool allowRemoval = false;
+            string classification = null;
+            string clientPatchId = null;
+            string description = null;
+            string displayName = null;
+            string comments = null;
+            string manufacturer = null;
+            YesNoType minorUpdateTargetRTM = YesNoType.NotSet;
+            string moreInfoUrl = null;
+            int optimizeCA = CompilerConstants.IntegerNotSet;
+            YesNoType optimizedInstallMode = YesNoType.NotSet;
+            string targetProductName = null;
+            // string replaceGuids = String.Empty;
+            int apiPatchingSymbolFlags = 0;
+            bool optimizePatchSizeForLargeFiles = false;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            patchId = this.core.GetAttributeGuidValue(sourceLineNumbers, attrib, true);
+                            break;
+                        case "Codepage":
+                            codepage = this.core.GetAttributeCodePageValue(sourceLineNumbers, attrib);
+                            break;
+                        case "AllowMajorVersionMismatches":
+                            ////versionMismatches = (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib));
+                            break;
+                        case "AllowProductCodeMismatches":
+                            ////productMismatches = (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib));
+                            break;
+                        case "AllowRemoval":
+                            allowRemoval = (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib));
+                            break;
+                        case "Classification":
+                            classification = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ClientPatchId":
+                            clientPatchId = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Description":
+                            description = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "DisplayName":
+                            displayName = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Comments":
+                            comments = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Manufacturer":
+                            manufacturer = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "MinorUpdateTargetRTM":
+                            minorUpdateTargetRTM = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "MoreInfoURL":
+                            moreInfoUrl = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "OptimizedInstallMode":
+                            optimizedInstallMode = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "TargetProductName":
+                            targetProductName = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ApiPatchingSymbolNoImagehlpFlag":
+                            apiPatchingSymbolFlags |= (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib)) ? (int)PatchAPI.PatchInterop.PatchSymbolFlagsType.PATCH_SYMBOL_NO_IMAGEHLP : 0;
+                            break;
+                        case "ApiPatchingSymbolNoFailuresFlag":
+                            apiPatchingSymbolFlags |= (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib)) ? (int)PatchAPI.PatchInterop.PatchSymbolFlagsType.PATCH_SYMBOL_NO_FAILURES : 0;
+                            break;
+                        case "ApiPatchingSymbolUndecoratedTooFlag":
+                            apiPatchingSymbolFlags |= (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib)) ? (int)PatchAPI.PatchInterop.PatchSymbolFlagsType.PATCH_SYMBOL_UNDECORATED_TOO : 0;
+                            break;
+                        case "OptimizePatchSizeForLargeFiles":
+                            optimizePatchSizeForLargeFiles = (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib));
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (patchId == null || patchId == "*")
+            {
+                // auto-generate at compile time, since this value gets dispersed to several locations
+                patchId = Common.GenerateGuid();
+            }
+            this.activeName = patchId;
+
+            if (null == this.activeName)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+            if (null == classification)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Classification"));
+            }
+            if (null == clientPatchId)
+            {
+                clientPatchId = String.Concat("_", new Guid(patchId).ToString("N", CultureInfo.InvariantCulture).ToUpper(CultureInfo.InvariantCulture));
+            }
+            if (null == description)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Description"));
+            }
+            if (null == displayName)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "DisplayName"));
+            }
+            if (null == manufacturer)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Manufacturer"));
+            }
+
+            this.core.CreateActiveSection(this.activeName, SectionType.Patch, codepage);
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "PatchInformation":
+                            this.ParsePatchInformationElement(child);
+                            break;
+                        case "Media":
+                            this.ParseMediaElement(child, patchId);
+                            break;
+                        case "OptimizeCustomActions":
+                            optimizeCA = this.ParseOptimizeCustomActionsElement(child);
+                            break;
+                        case "PatchFamily":
+                            this.ParsePatchFamilyElement(child, ComplexReferenceParentType.Patch, patchId);
+                            break;
+                        case "PatchFamilyRef":
+                            this.ParsePatchFamilyRefElement(child, ComplexReferenceParentType.Patch, patchId);
+                            break;
+                        case "PatchFamilyGroup":
+                            this.ParsePatchFamilyGroupElement(child, ComplexReferenceParentType.Patch, patchId);
+                            break;
+                        case "PatchFamilyGroupRef":
+                            this.ParsePatchFamilyGroupRefElement(child, ComplexReferenceParentType.Patch, patchId);
+                            break;
+                        case "PatchProperty":
+                            this.ParsePatchPropertyElement(child, true);
+                            break;
+                        case "TargetProductCodes":
+                            this.ParseTargetProductCodesElement(child);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+
+            if (!this.core.EncounteredError)
+            {
+                Row patchIdRow = this.core.CreateRow(sourceLineNumbers, "WixPatchId");
+                patchIdRow[0] = patchId;
+                patchIdRow[1] = clientPatchId;
+                patchIdRow[2] = optimizePatchSizeForLargeFiles ? 1 : 0;
+                patchIdRow[3] = apiPatchingSymbolFlags;
+
+                if (allowRemoval)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "MsiPatchMetadata");
+                    row[0] = null;
+                    row[1] = "AllowRemoval";
+                    row[2] = allowRemoval ? "1" : "0";
+                }
+
+                if (null != classification)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "MsiPatchMetadata");
+                    row[0] = null;
+                    row[1] = "Classification";
+                    row[2] = classification;
+                }
+
+                // always generate the CreationTimeUTC
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "MsiPatchMetadata");
+                    row[0] = null;
+                    row[1] = "CreationTimeUTC";
+                    row[2] = DateTime.UtcNow.ToString("MM-dd-yy HH:mm", CultureInfo.InvariantCulture);
+                }
+
+                if (null != description)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "MsiPatchMetadata");
+                    row[0] = null;
+                    row[1] = "Description";
+                    row[2] = description;
+                }
+
+                if (null != displayName)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "MsiPatchMetadata");
+                    row[0] = null;
+                    row[1] = "DisplayName";
+                    row[2] = displayName;
+                }
+
+                if (null != manufacturer)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "MsiPatchMetadata");
+                    row[0] = null;
+                    row[1] = "ManufacturerName";
+                    row[2] = manufacturer;
+                }
+
+                if (YesNoType.NotSet != minorUpdateTargetRTM)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "MsiPatchMetadata");
+                    row[0] = null;
+                    row[1] = "MinorUpdateTargetRTM";
+                    row[2] = YesNoType.Yes == minorUpdateTargetRTM ? "1" : "0";
+                }
+
+                if (null != moreInfoUrl)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "MsiPatchMetadata");
+                    row[0] = null;
+                    row[1] = "MoreInfoURL";
+                    row[2] = moreInfoUrl;
+                }
+
+                if (CompilerConstants.IntegerNotSet != optimizeCA)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "MsiPatchMetadata");
+                    row[0] = null;
+                    row[1] = "OptimizeCA";
+                    row[2] = optimizeCA.ToString(CultureInfo.InvariantCulture);
+                }
+
+                if (YesNoType.NotSet != optimizedInstallMode)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "MsiPatchMetadata");
+                    row[0] = null;
+                    row[1] = "OptimizedInstallMode";
+                    row[2] = YesNoType.Yes == optimizedInstallMode ? "1" : "0";
+                }
+
+                if (null != targetProductName)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "MsiPatchMetadata");
+                    row[0] = null;
+                    row[1] = "TargetProductName";
+                    row[2] = targetProductName;
+                }
+
+                if (null != comments)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "WixPatchMetadata");
+                    row[0] = "Comments";
+                    row[1] = comments;
+                }
+            }
+            // TODO: do something with versionMismatches and productMismatches
+        }
+
+        /// <summary>
+        /// Parses a PatchFamily element.
+        /// </summary>
+        /// <param name="node">The element to parse.</param>
+        private void ParsePatchFamilyElement(XElement node, ComplexReferenceParentType parentType, string parentId)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            string productCode = null;
+            string version = null;
+            int attributes = 0;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "ProductCode":
+                            productCode = this.core.GetAttributeGuidValue(sourceLineNumbers, attrib, false);
+                            break;
+                        case "Version":
+                            version = this.core.GetAttributeVersionValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Supersede":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= 0x1;
+                            }
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+                id = Identifier.Invalid;
+            }
+
+            if (String.IsNullOrEmpty(version))
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Version"));
+            }
+            else if (!CompilerCore.IsValidProductVersion(version))
+            {
+                this.core.OnMessage(WixErrors.InvalidProductVersion(sourceLineNumbers, version));
+            }
+
+            // find unexpected child elements
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "All":
+                            this.ParseAllElement(child);
+                            break;
+                        case "BinaryRef":
+                            this.ParsePatchChildRefElement(child, "Binary");
+                            break;
+                        case "ComponentRef":
+                            this.ParsePatchChildRefElement(child, "Component");
+                            break;
+                        case "CustomActionRef":
+                            this.ParsePatchChildRefElement(child, "CustomAction");
+                            break;
+                        case "DirectoryRef":
+                            this.ParsePatchChildRefElement(child, "Directory");
+                            break;
+                        case "DigitalCertificateRef":
+                            this.ParsePatchChildRefElement(child, "MsiDigitalCertificate");
+                            break;
+                        case "FeatureRef":
+                            this.ParsePatchChildRefElement(child, "Feature");
+                            break;
+                        case "IconRef":
+                            this.ParsePatchChildRefElement(child, "Icon");
+                            break;
+                        case "PropertyRef":
+                            this.ParsePatchChildRefElement(child, "Property");
+                            break;
+                        case "UIRef":
+                            this.ParsePatchChildRefElement(child, "WixUI");
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "MsiPatchSequence", id);
+                row[1] = productCode;
+                row[2] = version;
+                row[3] = attributes;
+
+                if (ComplexReferenceParentType.Unknown != parentType)
+                {
+                    this.core.CreateComplexReference(sourceLineNumbers, parentType, parentId, null, ComplexReferenceChildType.PatchFamily, id.Id, ComplexReferenceParentType.Patch == parentType);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses the All element under a PatchFamily.
+        /// </summary>
+        /// <param name="node">The element to parse.</param>
+        private void ParseAllElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+
+            // find unexpected attributes
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    this.core.UnexpectedAttribute(node, attrib);
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            // Always warn when using the All element.
+            this.core.OnMessage(WixWarnings.AllChangesIncludedInPatch(sourceLineNumbers));
+
+            if (!this.core.EncounteredError)
+            {
+                this.core.CreatePatchFamilyChildReference(sourceLineNumbers, "*", "*");
+            }
+        }
+
+        /// <summary>
+        /// Parses all reference elements under a PatchFamily.
+        /// </summary>
+        /// <param name="node">The element to parse.</param>
+        /// <param name="tableName">Table that reference was made to.</param>
+        private void ParsePatchChildRefElement(XElement node, string tableName)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string id = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                this.core.CreatePatchFamilyChildReference(sourceLineNumbers, tableName, id);
+            }
+        }
+
+        /// <summary>
+        /// Parses a PatchBaseline element.
+        /// </summary>
+        /// <param name="node">The element to parse.</param>
+        /// <param name="diskId">Media index from parent element.</param>
+        private void ParsePatchBaselineElement(XElement node, int diskId)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            bool parsedValidate = false;
+            TransformFlags validationFlags = TransformFlags.PatchTransformDefault;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+                id = Identifier.Invalid;
+            }
+            else if (27 < id.Id.Length)
+            {
+                this.core.OnMessage(WixErrors.IdentifierTooLongError(sourceLineNumbers, node.Name.LocalName, "Id", id.Id, 27));
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "Validate":
+                            if (parsedValidate)
+                            {
+                                SourceLineNumber childSourceLineNumbers = Preprocessor.GetSourceLineNumbers(child);
+                                this.core.OnMessage(WixErrors.TooManyChildren(childSourceLineNumbers, node.Name.LocalName, child.Name.LocalName));
+                            }
+                            else
+                            {
+                                this.ParseValidateElement(child, ref validationFlags);
+                                parsedValidate = true;
+                            }
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "WixPatchBaseline", id);
+                row[1] = diskId;
+                row[2] = (int)validationFlags;
+            }
+        }
+
+        /// <summary>
+        /// Parses a Validate element.
+        /// </summary>
+        /// <param name="node">The element to parse.</param>
+        /// <param name="validationFlags">TransformValidation flags to use when creating the authoring patch transform.</param>
+        private void ParseValidateElement(XElement node, ref TransformFlags validationFlags)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "ProductId":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                validationFlags |= TransformFlags.ValidateProduct;
+                            }
+                            else
+                            {
+                                validationFlags &= ~TransformFlags.ValidateProduct;
+                            }
+                            break;
+                        case "ProductLanguage":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                validationFlags |= TransformFlags.ValidateLanguage;
+                            }
+                            else
+                            {
+                                validationFlags &= ~TransformFlags.ValidateLanguage;
+                            }
+                            break;
+                        case "ProductVersion":
+                            string check = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            validationFlags &= ~TransformFlags.ProductVersionMask;
+                            Wix.Validate.ProductVersionType productVersionType = Wix.Validate.ParseProductVersionType(check);
+                            switch (productVersionType)
+                            {
+                                case Wix.Validate.ProductVersionType.Major:
+                                    validationFlags |= TransformFlags.ValidateMajorVersion;
+                                    break;
+                                case Wix.Validate.ProductVersionType.Minor:
+                                    validationFlags |= TransformFlags.ValidateMinorVersion;
+                                    break;
+                                case Wix.Validate.ProductVersionType.Update:
+                                    validationFlags |= TransformFlags.ValidateUpdateVersion;
+                                    break;
+                                default:
+                                    this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, "Version", check, "Major", "Minor", "Update"));
+                                    break;
+                            }
+                            break;
+                        case "ProductVersionOperator":
+                            string op = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            validationFlags &= ~TransformFlags.ProductVersionOperatorMask;
+                            Wix.Validate.ProductVersionOperatorType opType = Wix.Validate.ParseProductVersionOperatorType(op);
+                            switch (opType)
+                            {
+                                case Wix.Validate.ProductVersionOperatorType.Lesser:
+                                    validationFlags |= TransformFlags.ValidateNewLessBaseVersion;
+                                    break;
+                                case Wix.Validate.ProductVersionOperatorType.LesserOrEqual:
+                                    validationFlags |= TransformFlags.ValidateNewLessEqualBaseVersion;
+                                    break;
+                                case Wix.Validate.ProductVersionOperatorType.Equal:
+                                    validationFlags |= TransformFlags.ValidateNewEqualBaseVersion;
+                                    break;
+                                case Wix.Validate.ProductVersionOperatorType.GreaterOrEqual:
+                                    validationFlags |= TransformFlags.ValidateNewGreaterEqualBaseVersion;
+                                    break;
+                                case Wix.Validate.ProductVersionOperatorType.Greater:
+                                    validationFlags |= TransformFlags.ValidateNewGreaterBaseVersion;
+                                    break;
+                                default:
+                                    this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, "Operator", op, "Lesser", "LesserOrEqual", "Equal", "GreaterOrEqual", "Greater"));
+                                    break;
+                            }
+                            break;
+                        case "UpgradeCode":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                validationFlags |= TransformFlags.ValidateUpgradeCode;
+                            }
+                            else
+                            {
+                                validationFlags &= ~TransformFlags.ValidateUpgradeCode;
+                            }
+                            break;
+                        case "IgnoreAddExistingRow":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                validationFlags |= TransformFlags.ErrorAddExistingRow;
+                            }
+                            else
+                            {
+                                validationFlags &= ~TransformFlags.ErrorAddExistingRow;
+                            }
+                            break;
+                        case "IgnoreAddExistingTable":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                validationFlags |= TransformFlags.ErrorAddExistingTable;
+                            }
+                            else
+                            {
+                                validationFlags &= ~TransformFlags.ErrorAddExistingTable;
+                            }
+                            break;
+                        case "IgnoreDeleteMissingRow":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                validationFlags |= TransformFlags.ErrorDeleteMissingRow;
+                            }
+                            else
+                            {
+                                validationFlags &= ~TransformFlags.ErrorDeleteMissingRow;
+                            }
+                            break;
+                        case "IgnoreDeleteMissingTable":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                validationFlags |= TransformFlags.ErrorDeleteMissingTable;
+                            }
+                            else
+                            {
+                                validationFlags &= ~TransformFlags.ErrorDeleteMissingTable;
+                            }
+                            break;
+                        case "IgnoreUpdateMissingRow":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                validationFlags |= TransformFlags.ErrorUpdateMissingRow;
+                            }
+                            else
+                            {
+                                validationFlags &= ~TransformFlags.ErrorUpdateMissingRow;
+                            }
+                            break;
+                        case "IgnoreChangingCodePage":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                validationFlags |= TransformFlags.ErrorChangeCodePage;
+                            }
+                            else
+                            {
+                                validationFlags &= ~TransformFlags.ErrorChangeCodePage;
+                            }
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+        }
+
+        /// <summary>
+        /// Adds a row to the properties table.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line numbers.</param>
+        /// <param name="name">Name of the property.</param>
+        /// <param name="value">Value of the property.</param>
+        private void ProcessProperties(SourceLineNumber sourceLineNumbers, string name, string value)
+        {
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "Properties");
+                row[0] = name;
+                row[1] = value;
+            }
+        }
+
+        /// <summary>
+        /// Parses a dependency element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        private void ParseDependencyElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string requiredId = null;
+            int requiredLanguage = CompilerConstants.IntegerNotSet;
+            string requiredVersion = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "RequiredId":
+                            requiredId = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        case "RequiredLanguage":
+                            requiredLanguage = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, short.MaxValue);
+                            break;
+                        case "RequiredVersion":
+                            requiredVersion = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == requiredId)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "RequiredId"));
+                requiredId = String.Empty;
+            }
+
+            if (CompilerConstants.IntegerNotSet == requiredLanguage)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "RequiredLanguage"));
+                requiredLanguage = CompilerConstants.IllegalInteger;
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "ModuleDependency");
+                row[0] = this.activeName;
+                row[1] = this.activeLanguage;
+                row[2] = requiredId;
+                row[3] = requiredLanguage.ToString(CultureInfo.InvariantCulture);
+                row[4] = requiredVersion;
+            }
+        }
+
+        /// <summary>
+        /// Parses an exclusion element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        private void ParseExclusionElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string excludedId = null;
+            int excludeExceptLanguage = CompilerConstants.IntegerNotSet;
+            int excludeLanguage = CompilerConstants.IntegerNotSet;
+            string excludedLanguageField = "0";
+            string excludedMaxVersion = null;
+            string excludedMinVersion = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "ExcludedId":
+                            excludedId = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ExcludeExceptLanguage":
+                            excludeExceptLanguage = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, short.MaxValue);
+                            break;
+                        case "ExcludeLanguage":
+                            excludeLanguage = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, short.MaxValue);
+                            break;
+                        case "ExcludedMaxVersion":
+                            excludedMaxVersion = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ExcludedMinVersion":
+                            excludedMinVersion = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == excludedId)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "ExcludedId"));
+                excludedId = String.Empty;
+            }
+
+            if (CompilerConstants.IntegerNotSet != excludeExceptLanguage && CompilerConstants.IntegerNotSet != excludeLanguage)
+            {
+                this.core.OnMessage(WixErrors.IllegalModuleExclusionLanguageAttributes(sourceLineNumbers));
+            }
+            else if (CompilerConstants.IntegerNotSet != excludeExceptLanguage)
+            {
+                excludedLanguageField = Convert.ToString(-excludeExceptLanguage, CultureInfo.InvariantCulture);
+            }
+            else if (CompilerConstants.IntegerNotSet != excludeLanguage)
+            {
+                excludedLanguageField = Convert.ToString(excludeLanguage, CultureInfo.InvariantCulture);
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "ModuleExclusion");
+                row[0] = this.activeName;
+                row[1] = this.activeLanguage;
+                row[2] = excludedId;
+                row[3] = excludedLanguageField;
+                row[4] = excludedMinVersion;
+                row[5] = excludedMaxVersion;
+            }
+        }
+
+        /// <summary>
+        /// Parses a configuration element for a configurable merge module.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        private void ParseConfigurationElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            int attributes = 0;
+            string contextData = null;
+            string defaultValue = null;
+            string description = null;
+            string displayName = null;
+            int format = CompilerConstants.IntegerNotSet;
+            string helpKeyword = null;
+            string helpLocation = null;
+            string name = null;
+            string type = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Name":
+                            name = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ContextData":
+                            contextData = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Description":
+                            description = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "DefaultValue":
+                            defaultValue = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "DisplayName":
+                            displayName = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Format":
+                            string formatStr = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (0 < formatStr.Length)
+                            {
+                                Wix.Configuration.FormatType formatType = Wix.Configuration.ParseFormatType(formatStr);
+                                switch (formatType)
+                                {
+                                    case Wix.Configuration.FormatType.Text:
+                                        format = 0;
+                                        break;
+                                    case Wix.Configuration.FormatType.Key:
+                                        format = 1;
+                                        break;
+                                    case Wix.Configuration.FormatType.Integer:
+                                        format = 2;
+                                        break;
+                                    case Wix.Configuration.FormatType.Bitfield:
+                                        format = 3;
+                                        break;
+                                    default:
+                                        this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, "Format", formatStr, "Text", "Key", "Integer", "Bitfield"));
+                                        break;
+                                }
+                            }
+                            break;
+                        case "HelpKeyword":
+                            helpKeyword = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "HelpLocation":
+                            helpLocation = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "KeyNoOrphan":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= MsiInterop.MsidbMsmConfigurableOptionKeyNoOrphan;
+                            }
+                            break;
+                        case "NonNullable":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= MsiInterop.MsidbMsmConfigurableOptionNonNullable;
+                            }
+                            break;
+                        case "Type":
+                            type = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == name)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Name"));
+                name = String.Empty;
+            }
+
+            if (CompilerConstants.IntegerNotSet == format)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Format"));
+                format = CompilerConstants.IllegalInteger;
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "ModuleConfiguration");
+                row[0] = name;
+                row[1] = format;
+                row[2] = type;
+                row[3] = contextData;
+                row[4] = defaultValue;
+                row[5] = attributes;
+                row[6] = displayName;
+                row[7] = description;
+                row[8] = helpLocation;
+                row[9] = helpKeyword;
+            }
+        }
+
+        /// <summary>
+        /// Parses a substitution element for a configurable merge module.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        private void ParseSubstitutionElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string column = null;
+            string rowKeys = null;
+            string table = null;
+            string value = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Column":
+                            column = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Row":
+                            rowKeys = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Table":
+                            table = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Value":
+                            value = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == column)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Column"));
+                column = String.Empty;
+            }
+
+            if (null == table)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Table"));
+                table = String.Empty;
+            }
+
+            if (null == rowKeys)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Row"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "ModuleSubstitution");
+                row[0] = table;
+                row[1] = rowKeys;
+                row[2] = column;
+                row[3] = value;
+            }
+        }
+
+        /// <summary>
+        /// Parses an IgnoreTable element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        private void ParseIgnoreTableElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string id = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "ModuleIgnoreTable");
+                row[0] = id;
+            }
+        }
+
+        /// <summary>
+        /// Parses an odbc driver or translator element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="componentId">Identifier of parent component.</param>
+        /// <param name="fileId">Default identifer for driver/translator file.</param>
+        /// <param name="table">Table we're processing for.</param>
+        private void ParseODBCDriverOrTranslator(XElement node, string componentId, string fileId, TableDefinition table)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            string driver = fileId;
+            string name = null;
+            string setup = fileId;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "File":
+                            driver = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.core.CreateSimpleReference(sourceLineNumbers, "File", driver);
+                            break;
+                        case "Name":
+                            name = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "SetupFile":
+                            setup = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.core.CreateSimpleReference(sourceLineNumbers, "File", setup);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == name)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Name"));
+            }
+
+            if (null == id)
+            {
+                id = this.core.CreateIdentifier("odb", name, fileId, setup);
+            }
+
+            // drivers have a few possible children
+            if ("ODBCDriver" == table.Name)
+            {
+                // process any data sources for the driver
+                foreach (XElement child in node.Elements())
+                {
+                    if (CompilerCore.WixNamespace == child.Name.Namespace)
+                    {
+                        switch (child.Name.LocalName)
+                        {
+                            case "ODBCDataSource":
+                                string ignoredKeyPath = null;
+                                this.ParseODBCDataSource(child, componentId, name, out ignoredKeyPath);
+                                break;
+                            case "Property":
+                                this.ParseODBCProperty(child, id.Id, "ODBCAttribute");
+                                break;
+                            default:
+                                this.core.UnexpectedElement(node, child);
+                                break;
+                        }
+                    }
+                    else
+                    {
+                        this.core.ParseExtensionElement(node, child);
+                    }
+                }
+            }
+            else
+            {
+                this.core.ParseForExtensionElements(node);
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, table.Name, id);
+                row[1] = componentId;
+                row[2] = name;
+                row[3] = driver;
+                row[4] = setup;
+            }
+        }
+
+        /// <summary>
+        /// Parses a Property element underneath an ODBC driver or translator.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="parentId">Identifier of parent driver or translator.</param>
+        /// <param name="tableName">Name of the table to create property in.</param>
+        private void ParseODBCProperty(XElement node, string parentId, string tableName)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string id = null;
+            string propertyValue = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Value":
+                            propertyValue = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, tableName);
+                row[0] = parentId;
+                row[1] = id;
+                row[2] = propertyValue;
+            }
+        }
+
+        /// <summary>
+        /// Parse an odbc data source element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="componentId">Identifier of parent component.</param>
+        /// <param name="driverName">Default name of driver.</param>
+        /// <param name="possibleKeyPath">Identifier of this element in case it is a keypath.</param>
+        /// <returns>Yes if this element was marked as the parent component's key path, No if explicitly marked as not being a key path, or NotSet otherwise.</returns>
+        private YesNoType ParseODBCDataSource(XElement node, string componentId, string driverName, out string possibleKeyPath)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            YesNoType keyPath = YesNoType.NotSet;
+            string name = null;
+            int registration = CompilerConstants.IntegerNotSet;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "DriverName":
+                            driverName = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "KeyPath":
+                            keyPath = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Name":
+                            name = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Registration":
+                            string registrationValue = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (0 < registrationValue.Length)
+                            {
+                                Wix.ODBCDataSource.RegistrationType registrationType = Wix.ODBCDataSource.ParseRegistrationType(registrationValue);
+                                switch (registrationType)
+                                {
+                                    case Wix.ODBCDataSource.RegistrationType.machine:
+                                        registration = 0;
+                                        break;
+                                    case Wix.ODBCDataSource.RegistrationType.user:
+                                        registration = 1;
+                                        break;
+                                    default:
+                                        this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, "Registration", registrationValue, "machine", "user"));
+                                        break;
+                                }
+                            }
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (CompilerConstants.IntegerNotSet == registration)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Registration"));
+                registration = CompilerConstants.IllegalInteger;
+            }
+
+            if (null == id)
+            {
+                id = this.core.CreateIdentifier("odc", name, driverName, registration.ToString());
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "Property":
+                            this.ParseODBCProperty(child, id.Id, "ODBCSourceAttribute");
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "ODBCDataSource", id);
+                row[1] = componentId;
+                row[2] = name;
+                row[3] = driverName;
+                row[4] = registration;
+            }
+
+            possibleKeyPath = id.Id;
+            return keyPath;
+        }
+
+        /// <summary>
+        /// Parses a package element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="productAuthor">Default package author.</param>
+        /// <param name="moduleId">The module guid - this is necessary until Module/@Guid is removed.</param>
+        private void ParsePackageElement(XElement node, string productAuthor, string moduleId)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string codepage = "65001";
+            string comments = String.Format(CultureInfo.InvariantCulture, "This installer database contains the logic and data required to install {0}.", this.activeName);
+            string keywords = "Installer";
+            int msiVersion = 100; // lowest released version, really should be specified
+            string packageAuthor = productAuthor;
+            string packageCode = null;
+            string packageLanguages = this.activeLanguage;
+            string packageName = this.activeName;
+            string platform = null;
+            string platformValue = null;
+            YesNoDefaultType security = YesNoDefaultType.Default;
+            int sourceBits = (this.compilingModule ? 2 : 0);
+            Row row;
+            bool installPrivilegeSeen = false;
+            bool installScopeSeen = false;
+
+            switch (this.CurrentPlatform)
+            {
+                case Platform.X86:
+                    platform = "Intel";
+                    break;
+                case Platform.X64:
+                    platform = "x64";
+                    msiVersion = 200;
+                    break;
+                case Platform.IA64:
+                    platform = "Intel64";
+                    msiVersion = 200;
+                    break;
+                case Platform.ARM:
+                    platform = "Arm";
+                    msiVersion = 500;
+                    break;
+                default:
+                    throw new ArgumentException(WixStrings.EXP_UnknownPlatformEnum, this.CurrentPlatform.ToString());
+            }
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            packageCode = this.core.GetAttributeGuidValue(sourceLineNumbers, attrib, this.compilingProduct);
+                            break;
+                        case "AdminImage":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                sourceBits = sourceBits | 4;
+                            }
+                            break;
+                        case "Comments":
+                            comments = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Compressed":
+                            // merge modules must always be compressed, so this attribute is invalid
+                            if (this.compilingModule)
+                            {
+                                this.core.OnMessage(WixWarnings.DeprecatedPackageCompressedAttribute(sourceLineNumbers));
+                                // this.core.OnMessage(WixErrors.IllegalAttributeWhenNested(sourceLineNumbers, node.Name.LocalName, "Compressed", "Module"));
+                            }
+                            else if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                sourceBits = sourceBits | 2;
+                            }
+                            break;
+                        case "Description":
+                            packageName = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "InstallPrivileges":
+                            string installPrivileges = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (0 < installPrivileges.Length)
+                            {
+                                installPrivilegeSeen = true;
+                                Wix.Package.InstallPrivilegesType installPrivilegesType = Wix.Package.ParseInstallPrivilegesType(installPrivileges);
+                                switch (installPrivilegesType)
+                                {
+                                    case Wix.Package.InstallPrivilegesType.elevated:
+                                        // this is the default setting
+                                        break;
+                                    case Wix.Package.InstallPrivilegesType.limited:
+                                        sourceBits = sourceBits | 8;
+                                        break;
+                                    default:
+                                        this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, installPrivileges, "elevated", "limited"));
+                                        break;
+                                }
+                            }
+                            break;
+                        case "InstallScope":
+                            string installScope = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (0 < installScope.Length)
+                            {
+                                installScopeSeen = true;
+                                Wix.Package.InstallScopeType installScopeType = Wix.Package.ParseInstallScopeType(installScope);
+                                switch (installScopeType)
+                                {
+                                    case Wix.Package.InstallScopeType.perMachine:
+                                        row = this.core.CreateRow(sourceLineNumbers, "Property");
+                                        row[0] = "ALLUSERS";
+                                        row[1] = "1";
+                                        break;
+                                    case Wix.Package.InstallScopeType.perUser:
+                                        sourceBits = sourceBits | 8;
+                                        break;
+                                    default:
+                                        this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, installScope, "perMachine", "perUser"));
+                                        break;
+                                }
+                            }
+                            break;
+                        case "InstallerVersion":
+                            msiVersion = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, int.MaxValue);
+                            break;
+                        case "Keywords":
+                            keywords = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Languages":
+                            packageLanguages = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Manufacturer":
+                            packageAuthor = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if ("PUT-COMPANY-NAME-HERE" == packageAuthor)
+                            {
+                                this.core.OnMessage(WixWarnings.PlaceholderValue(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, packageAuthor));
+                            }
+                            break;
+                        case "Platform":
+                            if (null != platformValue)
+                            {
+                                this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, "Platforms"));
+                            }
+
+                            platformValue = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            Wix.Package.PlatformType platformType = Wix.Package.ParsePlatformType(platformValue);
+                            switch (platformType)
+                            {
+                                case Wix.Package.PlatformType.intel:
+                                    this.core.OnMessage(WixWarnings.DeprecatedAttributeValue(sourceLineNumbers, platformValue, node.Name.LocalName, attrib.Name.LocalName, "x86"));
+                                    goto case Wix.Package.PlatformType.x86;
+                                case Wix.Package.PlatformType.x86:
+                                    platform = "Intel";
+                                    break;
+                                case Wix.Package.PlatformType.x64:
+                                    platform = "x64";
+                                    break;
+                                case Wix.Package.PlatformType.intel64:
+                                    this.core.OnMessage(WixWarnings.DeprecatedAttributeValue(sourceLineNumbers, platformValue, node.Name.LocalName, attrib.Name.LocalName, "ia64"));
+                                    goto case Wix.Package.PlatformType.ia64;
+                                case Wix.Package.PlatformType.ia64:
+                                    platform = "Intel64";
+                                    break;
+                                case Wix.Package.PlatformType.arm:
+                                    platform = "Arm";
+                                    break;
+                                default:
+                                    this.core.OnMessage(WixErrors.InvalidPlatformValue(sourceLineNumbers, platformValue));
+                                    break;
+                            }
+                            break;
+                        case "Platforms":
+                            if (null != platformValue)
+                            {
+                                this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, "Platform"));
+                            }
+
+                            this.core.OnMessage(WixWarnings.DeprecatedAttribute(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, "Platform"));
+                            platformValue = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            platform = platformValue;
+                            break;
+                        case "ReadOnly":
+                            security = this.core.GetAttributeYesNoDefaultValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ShortNames":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                sourceBits = sourceBits | 1;
+                                this.useShortFileNames = true;
+                            }
+                            break;
+                        case "SummaryCodepage":
+                            codepage = this.core.GetAttributeLocalizableCodePageValue(sourceLineNumbers, attrib, true);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (installPrivilegeSeen && installScopeSeen)
+            {
+                this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "InstallPrivileges", "InstallScope"));
+            }
+
+            if ((0 != String.Compare(platform, "Intel", StringComparison.OrdinalIgnoreCase)) && 200 > msiVersion)
+            {
+                msiVersion = 200;
+                this.core.OnMessage(WixWarnings.RequiresMsi200for64bitPackage(sourceLineNumbers));
+            }
+
+            if ((0 == String.Compare(platform, "Arm", StringComparison.OrdinalIgnoreCase)) && 500 > msiVersion)
+            {
+                msiVersion = 500;
+                this.core.OnMessage(WixWarnings.RequiresMsi500forArmPackage(sourceLineNumbers));
+            }
+
+            if (null == packageAuthor)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Manufacturer"));
+            }
+
+            if (this.compilingModule)
+            {
+                if (null == packageCode)
+                {
+                    this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+                }
+
+                // merge modules use the modularization guid as the package code
+                if (null != moduleId)
+                {
+                    packageCode = moduleId;
+                }
+
+                // merge modules are always compressed
+                sourceBits = 2;
+            }
+            else // product
+            {
+                if (null == packageCode)
+                {
+                    packageCode = "*";
+                }
+
+                if ("*" != packageCode)
+                {
+                    this.core.OnMessage(WixWarnings.PackageCodeSet(sourceLineNumbers));
+                }
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                row = this.core.CreateRow(sourceLineNumbers, "_SummaryInformation");
+                row[0] = 1;
+                row[1] = codepage;
+
+                row = this.core.CreateRow(sourceLineNumbers, "_SummaryInformation");
+                row[0] = 2;
+                row[1] = "Installation Database";
+
+                row = this.core.CreateRow(sourceLineNumbers, "_SummaryInformation");
+                row[0] = 3;
+                row[1] = packageName;
+
+                row = this.core.CreateRow(sourceLineNumbers, "_SummaryInformation");
+                row[0] = 4;
+                row[1] = packageAuthor;
+
+                row = this.core.CreateRow(sourceLineNumbers, "_SummaryInformation");
+                row[0] = 5;
+                row[1] = keywords;
+
+                row = this.core.CreateRow(sourceLineNumbers, "_SummaryInformation");
+                row[0] = 6;
+                row[1] = comments;
+
+                row = this.core.CreateRow(sourceLineNumbers, "_SummaryInformation");
+                row[0] = 7;
+                row[1] = String.Format(CultureInfo.InvariantCulture, "{0};{1}", platform, packageLanguages);
+
+                row = this.core.CreateRow(sourceLineNumbers, "_SummaryInformation");
+                row[0] = 9;
+                row[1] = packageCode;
+
+                row = this.core.CreateRow(sourceLineNumbers, "_SummaryInformation");
+                row[0] = 14;
+                row[1] = msiVersion.ToString(CultureInfo.InvariantCulture);
+
+                row = this.core.CreateRow(sourceLineNumbers, "_SummaryInformation");
+                row[0] = 15;
+                row[1] = sourceBits.ToString(CultureInfo.InvariantCulture);
+
+                row = this.core.CreateRow(sourceLineNumbers, "_SummaryInformation");
+                row[0] = 19;
+                switch (security)
+                {
+                    case YesNoDefaultType.No: // no restriction
+                        row[1] = "0";
+                        break;
+                    case YesNoDefaultType.Default: // read-only recommended
+                        row[1] = "2";
+                        break;
+                    case YesNoDefaultType.Yes: // read-only enforced
+                        row[1] = "4";
+                        break;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses a patch metadata element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        private void ParsePatchMetadataElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            YesNoType allowRemoval = YesNoType.NotSet;
+            string classification = null;
+            string creationTimeUtc = null;
+            string description = null;
+            string displayName = null;
+            string manufacturerName = null;
+            string minorUpdateTargetRTM = null;
+            string moreInfoUrl = null;
+            int optimizeCA = CompilerConstants.IntegerNotSet;
+            YesNoType optimizedInstallMode = YesNoType.NotSet;
+            string targetProductName = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "AllowRemoval":
+                            allowRemoval = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Classification":
+                            classification = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "CreationTimeUTC":
+                            creationTimeUtc = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Description":
+                            description = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "DisplayName":
+                            displayName = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ManufacturerName":
+                            manufacturerName = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "MinorUpdateTargetRTM":
+                            minorUpdateTargetRTM = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "MoreInfoURL":
+                            moreInfoUrl = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "OptimizedInstallMode":
+                            optimizedInstallMode = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "TargetProductName":
+                            targetProductName = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (YesNoType.NotSet == allowRemoval)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "AllowRemoval"));
+            }
+
+            if (null == classification)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Classification"));
+            }
+
+            if (null == description)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Description"));
+            }
+
+            if (null == displayName)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "DisplayName"));
+            }
+
+            if (null == manufacturerName)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "ManufacturerName"));
+            }
+
+            if (null == moreInfoUrl)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "MoreInfoURL"));
+            }
+
+            if (null == targetProductName)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "TargetProductName"));
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "CustomProperty":
+                            this.ParseCustomPropertyElement(child);
+                            break;
+                        case "OptimizeCustomActions":
+                            optimizeCA = this.ParseOptimizeCustomActionsElement(child);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                if (YesNoType.NotSet != allowRemoval)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "PatchMetadata");
+                    row[0] = null;
+                    row[1] = "AllowRemoval";
+                    row[2] = YesNoType.Yes == allowRemoval ? "1" : "0";
+                }
+
+                if (null != classification)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "PatchMetadata");
+                    row[0] = null;
+                    row[1] = "Classification";
+                    row[2] = classification;
+                }
+
+                if (null != creationTimeUtc)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "PatchMetadata");
+                    row[0] = null;
+                    row[1] = "CreationTimeUTC";
+                    row[2] = creationTimeUtc;
+                }
+
+                if (null != description)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "PatchMetadata");
+                    row[0] = null;
+                    row[1] = "Description";
+                    row[2] = description;
+                }
+
+                if (null != displayName)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "PatchMetadata");
+                    row[0] = null;
+                    row[1] = "DisplayName";
+                    row[2] = displayName;
+                }
+
+                if (null != manufacturerName)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "PatchMetadata");
+                    row[0] = null;
+                    row[1] = "ManufacturerName";
+                    row[2] = manufacturerName;
+                }
+
+                if (null != minorUpdateTargetRTM)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "PatchMetadata");
+                    row[0] = null;
+                    row[1] = "MinorUpdateTargetRTM";
+                    row[2] = minorUpdateTargetRTM;
+                }
+
+                if (null != moreInfoUrl)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "PatchMetadata");
+                    row[0] = null;
+                    row[1] = "MoreInfoURL";
+                    row[2] = moreInfoUrl;
+                }
+
+                if (CompilerConstants.IntegerNotSet != optimizeCA)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "PatchMetadata");
+                    row[0] = null;
+                    row[1] = "OptimizeCA";
+                    row[2] = optimizeCA.ToString(CultureInfo.InvariantCulture);
+                }
+
+                if (YesNoType.NotSet != optimizedInstallMode)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "PatchMetadata");
+                    row[0] = null;
+                    row[1] = "OptimizedInstallMode";
+                    row[2] = YesNoType.Yes == optimizedInstallMode ? "1" : "0";
+                }
+
+                if (null != targetProductName)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "PatchMetadata");
+                    row[0] = null;
+                    row[1] = "TargetProductName";
+                    row[2] = targetProductName;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses a custom property element for the PatchMetadata table.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        private void ParseCustomPropertyElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string company = null;
+            string property = null;
+            string value = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Company":
+                            company = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Property":
+                            property = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Value":
+                            value = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == company)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Company"));
+            }
+
+            if (null == property)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Property"));
+            }
+
+            if (null == value)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Value"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "PatchMetadata");
+                row[0] = company;
+                row[1] = property;
+                row[2] = value;
+            }
+        }
+
+        /// <summary>
+        /// Parses the OptimizeCustomActions element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <returns>The combined integer value for callers to store as appropriate.</returns>
+        private int ParseOptimizeCustomActionsElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            OptimizeCA optimizeCA = OptimizeCA.None;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "SkipAssignment":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                optimizeCA |= OptimizeCA.SkipAssignment;
+                            }
+                            break;
+                        case "SkipImmediate":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                optimizeCA |= OptimizeCA.SkipImmediate;
+                            }
+                            break;
+                        case "SkipDeferred":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                optimizeCA |= OptimizeCA.SkipDeferred;
+                            }
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            return (int)optimizeCA;
+        }
+
+        /// <summary>
+        /// Parses a patch information element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        private void ParsePatchInformationElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string codepage = "65001";
+            string comments = null;
+            string keywords = "Installer,Patching,PCP,Database";
+            int msiVersion = 1; // Should always be 1 for patches
+            string packageAuthor = null;
+            string packageName = this.activeName;
+            YesNoDefaultType security = YesNoDefaultType.Default;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "AdminImage":
+                            this.core.OnMessage(WixWarnings.DeprecatedAttribute(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName));
+                            break;
+                        case "Comments":
+                            comments = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Compressed":
+                            this.core.OnMessage(WixWarnings.DeprecatedAttribute(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName));
+                            break;
+                        case "Description":
+                            packageName = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Keywords":
+                            keywords = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Languages":
+                            this.core.OnMessage(WixWarnings.DeprecatedAttribute(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName));
+                            break;
+                        case "Manufacturer":
+                            packageAuthor = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Platforms":
+                            this.core.OnMessage(WixWarnings.DeprecatedAttribute(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName));
+                            break;
+                        case "ReadOnly":
+                            security = this.core.GetAttributeYesNoDefaultValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ShortNames":
+                            this.core.OnMessage(WixWarnings.DeprecatedAttribute(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName));
+                            break;
+                        case "SummaryCodepage":
+                            codepage = this.core.GetAttributeLocalizableCodePageValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                // PID_CODEPAGE
+                Row row = this.core.CreateRow(sourceLineNumbers, "_SummaryInformation");
+                row[0] = 1;
+                row[1] = codepage;
+
+                // PID_TITLE
+                row = this.core.CreateRow(sourceLineNumbers, "_SummaryInformation");
+                row[0] = 2;
+                row[1] = "Patch";
+
+                // PID_SUBJECT
+                if (null != packageName)
+                {
+                    row = this.core.CreateRow(sourceLineNumbers, "_SummaryInformation");
+                    row[0] = 3;
+                    row[1] = packageName;
+                }
+
+                // PID_AUTHOR
+                if (null != packageAuthor)
+                {
+                    row = this.core.CreateRow(sourceLineNumbers, "_SummaryInformation");
+                    row[0] = 4;
+                    row[1] = packageAuthor;
+                }
+
+                // PID_KEYWORDS
+                if (null != keywords)
+                {
+                    row = this.core.CreateRow(sourceLineNumbers, "_SummaryInformation");
+                    row[0] = 5;
+                    row[1] = keywords;
+                }
+
+                // PID_COMMENTS
+                if (null != comments)
+                {
+                    row = this.core.CreateRow(sourceLineNumbers, "_SummaryInformation");
+                    row[0] = 6;
+                    row[1] = comments;
+                }
+
+                // PID_PAGECOUNT
+                row = this.core.CreateRow(sourceLineNumbers, "_SummaryInformation");
+                row[0] = 14;
+                row[1] = msiVersion.ToString(CultureInfo.InvariantCulture);
+
+                // PID_WORDCOUNT
+                row = this.core.CreateRow(sourceLineNumbers, "_SummaryInformation");
+                row[0] = 15;
+                row[1] = "0";
+
+                // PID_SECURITY
+                row = this.core.CreateRow(sourceLineNumbers, "_SummaryInformation");
+                row[0] = 19;
+                switch (security)
+                {
+                    case YesNoDefaultType.No: // no restriction
+                        row[1] = "0";
+                        break;
+                    case YesNoDefaultType.Default: // read-only recommended
+                        row[1] = "2";
+                        break;
+                    case YesNoDefaultType.Yes: // read-only enforced
+                        row[1] = "4";
+                        break;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses an ignore modularization element.
+        /// </summary>
+        /// <param name="node">XmlNode on an IgnoreModulatization element.</param>
+        private void ParseIgnoreModularizationElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string name = null;
+
+            this.core.OnMessage(WixWarnings.DeprecatedIgnoreModularizationElement(sourceLineNumbers));
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Name":
+                            name = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Type":
+                            // this is actually not used
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == name)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Name"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "WixSuppressModularization");
+                row[0] = name;
+            }
+        }
+
+        /// <summary>
+        /// Parses a permission element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="objectId">Identifier of object to be secured.</param>
+        /// <param name="tableName">Name of table that contains objectId.</param>
+        private void ParsePermissionElement(XElement node, string objectId, string tableName)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            BitArray bits = new BitArray(32);
+            string domain = null;
+            int permission = 0;
+            string[] specialPermissions = null;
+            string user = null;
+
+            switch (tableName)
+            {
+                case "CreateFolder":
+                    specialPermissions = Common.FolderPermissions;
+                    break;
+                case "File":
+                    specialPermissions = Common.FilePermissions;
+                    break;
+                case "Registry":
+                    specialPermissions = Common.RegistryPermissions;
+                    break;
+                default:
+                    this.core.UnexpectedElement(node.Parent, node);
+                    return; // stop processing this element since no valid permissions are available
+            }
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Domain":
+                            domain = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "User":
+                            user = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "FileAllRights":
+                            // match the WinNT.h mask FILE_ALL_ACCESS for value 0x001F01FF (aka 1 1111 0000 0001 1111 1111 or 2032127)
+                            bits[0] = bits[1] = bits[2] = bits[3] = bits[4] = bits[5] = bits[6] = bits[7] = bits[8] = bits[16] = bits[17] = bits[18] = bits[19] = bits[20] = true;
+                            break;
+                        case "SpecificRightsAll":
+                            // match the WinNT.h mask SPECIFIC_RIGHTS_ALL for value 0x0000FFFF (aka 1111 1111 1111 1111)
+                            bits[0] = bits[1] = bits[2] = bits[3] = bits[4] = bits[5] = bits[6] = bits[7] = bits[8] = bits[9] = bits[10] = bits[11] = bits[12] = bits[13] = bits[14] = bits[15] = true;
+                            break;
+                        default:
+                            YesNoType attribValue = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            if (!this.core.TrySetBitFromName(Common.StandardPermissions, attrib.Name.LocalName, attribValue, bits, 16))
+                            {
+                                if (!this.core.TrySetBitFromName(Common.GenericPermissions, attrib.Name.LocalName, attribValue, bits, 28))
+                                {
+                                    if (!this.core.TrySetBitFromName(specialPermissions, attrib.Name.LocalName, attribValue, bits, 0))
+                                    {
+                                        this.core.UnexpectedAttribute(node, attrib);
+                                        break;
+                                    }
+                                }
+                            }
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            permission = this.core.CreateIntegerFromBitArray(bits);
+
+            if (null == user)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "User"));
+            }
+
+            if (int.MinValue == permission) // just GENERIC_READ, which is MSI_NULL
+            {
+                this.core.OnMessage(WixErrors.GenericReadNotAllowed(sourceLineNumbers));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "LockPermissions");
+                row[0] = objectId;
+                row[1] = tableName;
+                row[2] = domain;
+                row[3] = user;
+                row[4] = permission;
+            }
+        }
+
+        /// <summary>
+        /// Parses an extended permission element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="objectId">Identifier of object to be secured.</param>
+        /// <param name="tableName">Name of table that contains objectId.</param>
+        private void ParsePermissionExElement(XElement node, string objectId, string tableName)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string condition = null;
+            Identifier id = null;
+            string sddl = null;
+
+            switch (tableName)
+            {
+                case "CreateFolder":
+                case "File":
+                case "Registry":
+                case "ServiceInstall":
+                    break;
+                default:
+                    this.core.UnexpectedElement(node.Parent, node);
+                    return; // stop processing this element since nothing will be valid.
+            }
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Sddl":
+                            sddl = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == sddl)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Sddl"));
+            }
+
+            if (null == id)
+            {
+                id = this.core.CreateIdentifier("pme", objectId, tableName, sddl);
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "Condition":
+                            if (null != condition)
+                            {
+                                SourceLineNumber childSourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+                                this.core.OnMessage(WixErrors.TooManyChildren(childSourceLineNumbers, node.Name.LocalName, child.Name.LocalName));
+                            }
+
+                            condition = this.ParseConditionElement(child, node.Name.LocalName, null, null);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "MsiLockPermissionsEx", id);
+                row[1] = objectId;
+                row[2] = tableName;
+                row[3] = sddl;
+                row[4] = condition;
+            }
+        }
+
+        /// <summary>
+        /// Parses a product element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1800:DoNotCastUnnecessarily")]
+        private void ParseProductElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            int codepage = 0;
+            string productCode = null;
+            string upgradeCode = null;
+            string manufacturer = null;
+            string version = null;
+            string symbols = null;
+
+            this.activeName = null;
+            this.activeLanguage = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            productCode = this.core.GetAttributeGuidValue(sourceLineNumbers, attrib, true);
+                            break;
+                        case "Codepage":
+                            codepage = this.core.GetAttributeCodePageValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Language":
+                            this.activeLanguage = this.core.GetAttributeLocalizableIntegerValue(sourceLineNumbers, attrib, 0, short.MaxValue);
+                            break;
+                        case "Manufacturer":
+                            manufacturer = this.core.GetAttributeValue(sourceLineNumbers, attrib, EmptyRule.MustHaveNonWhitespaceCharacters);
+                            if ("PUT-COMPANY-NAME-HERE" == manufacturer)
+                            {
+                                this.core.OnMessage(WixWarnings.PlaceholderValue(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, manufacturer));
+                            }
+                            break;
+                        case "Name":
+                            this.activeName = this.core.GetAttributeValue(sourceLineNumbers, attrib, EmptyRule.MustHaveNonWhitespaceCharacters);
+                            if ("PUT-PRODUCT-NAME-HERE" == this.activeName)
+                            {
+                                this.core.OnMessage(WixWarnings.PlaceholderValue(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, this.activeName));
+                            }
+                            break;
+                        case "UpgradeCode":
+                            upgradeCode = this.core.GetAttributeGuidValue(sourceLineNumbers, attrib, false);
+                            break;
+                        case "Version": // if the attribute is valid version, use the attribute value as is (so "1.0000.01.01" would *not* get translated to "1.0.1.1").
+                            string verifiedVersion = this.core.GetAttributeVersionValue(sourceLineNumbers, attrib);
+                            if (!String.IsNullOrEmpty(verifiedVersion))
+                            {
+                                version = attrib.Value;
+                            }
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == productCode)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            if (null == this.activeLanguage)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Language"));
+            }
+
+            if (null == manufacturer)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Manufacturer"));
+            }
+
+            if (null == this.activeName)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Name"));
+            }
+
+            if (null == upgradeCode)
+            {
+                this.core.OnMessage(WixWarnings.MissingUpgradeCode(sourceLineNumbers));
+            }
+
+            if (null == version)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Version"));
+            }
+            else if (!CompilerCore.IsValidProductVersion(version))
+            {
+                this.core.OnMessage(WixErrors.InvalidProductVersion(sourceLineNumbers, version));
+            }
+
+            if (this.core.EncounteredError)
+            {
+                return;
+            }
+
+            try
+            {
+                this.compilingProduct = true;
+                this.core.CreateActiveSection(productCode, SectionType.Product, codepage);
+
+                this.AddProperty(sourceLineNumbers, new Identifier("Manufacturer", AccessModifier.Public), manufacturer, false, false, false, true);
+                this.AddProperty(sourceLineNumbers, new Identifier("ProductCode", AccessModifier.Public), productCode, false, false, false, true);
+                this.AddProperty(sourceLineNumbers, new Identifier("ProductLanguage", AccessModifier.Public), this.activeLanguage, false, false, false, true);
+                this.AddProperty(sourceLineNumbers, new Identifier("ProductName", AccessModifier.Public), this.activeName, false, false, false, true);
+                this.AddProperty(sourceLineNumbers, new Identifier("ProductVersion", AccessModifier.Public), version, false, false, false, true);
+                if (null != upgradeCode)
+                {
+                    this.AddProperty(sourceLineNumbers, new Identifier("UpgradeCode", AccessModifier.Public), upgradeCode, false, false, false, true);
+                }
+
+                Dictionary<string, string> contextValues = new Dictionary<string, string>();
+                contextValues["ProductLanguage"] = this.activeLanguage;
+                contextValues["ProductVersion"] = version;
+                contextValues["UpgradeCode"] = upgradeCode;
+
+                int featureDisplay = 0;
+                foreach (XElement child in node.Elements())
+                {
+                    if (CompilerCore.WixNamespace == child.Name.Namespace)
+                    {
+                        switch (child.Name.LocalName)
+                        {
+                            case "_locDefinition":
+                                break;
+                            case "AdminExecuteSequence":
+                            case "AdminUISequence":
+                            case "AdvertiseExecuteSequence":
+                            case "InstallExecuteSequence":
+                            case "InstallUISequence":
+                                this.ParseSequenceElement(child, child.Name.LocalName);
+                                break;
+                            case "AppId":
+                                this.ParseAppIdElement(child, null, YesNoType.Yes, null, null, null);
+                                break;
+                            case "Binary":
+                                this.ParseBinaryElement(child);
+                                break;
+                            case "ComplianceCheck":
+                                this.ParseComplianceCheckElement(child);
+                                break;
+                            case "Component":
+                                this.ParseComponentElement(child, ComplexReferenceParentType.Unknown, null, null, CompilerConstants.IntegerNotSet, null, null);
+                                break;
+                            case "ComponentGroup":
+                                this.ParseComponentGroupElement(child, ComplexReferenceParentType.Unknown, null);
+                                break;
+                            case "Condition":
+                                this.ParseConditionElement(child, node.Name.LocalName, null, null);
+                                break;
+                            case "CustomAction":
+                                this.ParseCustomActionElement(child);
+                                break;
+                            case "CustomActionRef":
+                                this.ParseSimpleRefElement(child, "CustomAction");
+                                break;
+                            case "CustomTable":
+                                this.ParseCustomTableElement(child);
+                                break;
+                            case "Directory":
+                                this.ParseDirectoryElement(child, null, CompilerConstants.IntegerNotSet, String.Empty);
+                                break;
+                            case "DirectoryRef":
+                                this.ParseDirectoryRefElement(child);
+                                break;
+                            case "EmbeddedChainer":
+                                this.ParseEmbeddedChainerElement(child);
+                                break;
+                            case "EmbeddedChainerRef":
+                                this.ParseSimpleRefElement(child, "MsiEmbeddedChainer");
+                                break;
+                            case "EnsureTable":
+                                this.ParseEnsureTableElement(child);
+                                break;
+                            case "Feature":
+                                this.ParseFeatureElement(child, ComplexReferenceParentType.Product, productCode, ref featureDisplay);
+                                break;
+                            case "FeatureRef":
+                                this.ParseFeatureRefElement(child, ComplexReferenceParentType.Product, productCode);
+                                break;
+                            case "FeatureGroupRef":
+                                this.ParseFeatureGroupRefElement(child, ComplexReferenceParentType.Product, productCode);
+                                break;
+                            case "Icon":
+                                this.ParseIconElement(child);
+                                break;
+                            case "InstanceTransforms":
+                                this.ParseInstanceTransformsElement(child);
+                                break;
+                            case "MajorUpgrade":
+                                this.ParseMajorUpgradeElement(child, contextValues);
+                                break;
+                            case "Media":
+                                this.ParseMediaElement(child, null);
+                                break;
+                            case "MediaTemplate":
+                                this.ParseMediaTemplateElement(child, null);
+                                break;
+                            case "Package":
+                                this.ParsePackageElement(child, manufacturer, null);
+                                break;
+                            case "PackageCertificates":
+                            case "PatchCertificates":
+                                this.ParseCertificatesElement(child);
+                                break;
+                            case "Property":
+                                this.ParsePropertyElement(child);
+                                break;
+                            case "PropertyRef":
+                                this.ParseSimpleRefElement(child, "Property");
+                                break;
+                            case "SetDirectory":
+                                this.ParseSetDirectoryElement(child);
+                                break;
+                            case "SetProperty":
+                                this.ParseSetPropertyElement(child);
+                                break;
+                            case "SFPCatalog":
+                                string parentName = null;
+                                this.ParseSFPCatalogElement(child, ref parentName);
+                                break;
+                            case "SymbolPath":
+                                if (null != symbols)
+                                {
+                                    symbols += ";" + this.ParseSymbolPathElement(child);
+                                }
+                                else
+                                {
+                                    symbols = this.ParseSymbolPathElement(child);
+                                }
+                                break;
+                            case "UI":
+                                this.ParseUIElement(child);
+                                break;
+                            case "UIRef":
+                                this.ParseSimpleRefElement(child, "WixUI");
+                                break;
+                            case "Upgrade":
+                                this.ParseUpgradeElement(child);
+                                break;
+                            case "WixVariable":
+                                this.ParseWixVariableElement(child);
+                                break;
+                            default:
+                                this.core.UnexpectedElement(node, child);
+                                break;
+                        }
+                    }
+                    else
+                    {
+                        this.core.ParseExtensionElement(node, child);
+                    }
+                }
+
+                if (!this.core.EncounteredError)
+                {
+                    if (null != symbols)
+                    {
+                        WixDeltaPatchSymbolPathsRow symbolRow = (WixDeltaPatchSymbolPathsRow)this.core.CreateRow(sourceLineNumbers, "WixDeltaPatchSymbolPaths");
+                        symbolRow.Id = productCode;
+                        symbolRow.Type = SymbolPathType.Product;
+                        symbolRow.SymbolPaths = symbols;
+                    }
+                }
+            }
+            finally
+            {
+                this.compilingProduct = false;
+            }
+        }
+
+        /// <summary>
+        /// Parses a progid element
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="componentId">Identifier of parent component.</param>
+        /// <param name="advertise">Flag if progid is advertised.</param>
+        /// <param name="classId">CLSID related to ProgId.</param>
+        /// <param name="description">Default description of ProgId</param>
+        /// <param name="parent">Optional parent ProgId</param>
+        /// <param name="foundExtension">Set to true if an extension is found; used for error-checking.</param>
+        /// <param name="firstProgIdForClass">Whether or not this ProgId is the first one found in the parent class.</param>
+        /// <returns>This element's Id.</returns>
+        private string ParseProgIdElement(XElement node, string componentId, YesNoType advertise, string classId, string description, string parent, ref bool foundExtension, YesNoType firstProgIdForClass)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string icon = null;
+            int iconIndex = CompilerConstants.IntegerNotSet;
+            string noOpen = null;
+            string progId = null;
+            YesNoType progIdAdvertise = YesNoType.NotSet;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            progId = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Advertise":
+                            progIdAdvertise = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Description":
+                            description = this.core.GetAttributeValue(sourceLineNumbers, attrib, EmptyRule.CanBeEmpty);
+                            break;
+                        case "Icon":
+                            icon = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        case "IconIndex":
+                            iconIndex = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, short.MinValue + 1, short.MaxValue);
+                            break;
+                        case "NoOpen":
+                            noOpen = this.core.GetAttributeValue(sourceLineNumbers, attrib, EmptyRule.CanBeEmpty);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if ((YesNoType.No == advertise && YesNoType.Yes == progIdAdvertise) || (YesNoType.Yes == advertise && YesNoType.No == progIdAdvertise))
+            {
+                this.core.OnMessage(WixErrors.AdvertiseStateMustMatch(sourceLineNumbers, advertise.ToString(), progIdAdvertise.ToString()));
+            }
+            else
+            {
+                advertise = progIdAdvertise;
+            }
+
+            if (YesNoType.NotSet == advertise)
+            {
+                advertise = YesNoType.No;
+            }
+
+            if (null != parent && (null != icon || CompilerConstants.IntegerNotSet != iconIndex))
+            {
+                this.core.OnMessage(WixErrors.VersionIndependentProgIdsCannotHaveIcons(sourceLineNumbers));
+            }
+
+            YesNoType firstProgIdForNestedClass = YesNoType.Yes;
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "Extension":
+                            this.ParseExtensionElement(child, componentId, advertise, progId);
+                            foundExtension = true;
+                            break;
+                        case "ProgId":
+                            // Only allow one nested ProgId.  If we have a child, we should not have a parent.
+                            if (null == parent)
+                            {
+                                if (YesNoType.Yes == advertise)
+                                {
+                                    this.ParseProgIdElement(child, componentId, advertise, null, description, progId, ref foundExtension, firstProgIdForNestedClass);
+                                }
+                                else if (YesNoType.No == advertise)
+                                {
+                                    this.ParseProgIdElement(child, componentId, advertise, classId, description, progId, ref foundExtension, firstProgIdForNestedClass);
+                                }
+
+                                firstProgIdForNestedClass = YesNoType.No; // any ProgId after this one is definitely not the first.
+                            }
+                            else
+                            {
+                                SourceLineNumber childSourceLineNumbers = Preprocessor.GetSourceLineNumbers(child);
+                                this.core.OnMessage(WixErrors.ProgIdNestedTooDeep(childSourceLineNumbers));
+                            }
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (YesNoType.Yes == advertise)
+            {
+                if (!this.core.EncounteredError)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "ProgId");
+                    row[0] = progId;
+                    row[1] = parent;
+                    row[2] = classId;
+                    row[3] = description;
+                    if (null != icon)
+                    {
+                        row[4] = icon;
+                        this.core.CreateSimpleReference(sourceLineNumbers, "Icon", icon);
+                    }
+
+                    if (CompilerConstants.IntegerNotSet != iconIndex)
+                    {
+                        row[5] = iconIndex;
+                    }
+
+                    this.core.EnsureTable(sourceLineNumbers, "Class");
+                }
+            }
+            else if (YesNoType.No == advertise)
+            {
+                this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, progId, String.Empty, description, componentId);
+                if (null != classId)
+                {
+                    this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat(progId, "\\CLSID"), String.Empty, classId, componentId);
+                    if (null != parent)   // if this is a version independent ProgId
+                    {
+                        if (YesNoType.Yes == firstProgIdForClass)
+                        {
+                            this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("CLSID\\", classId, "\\VersionIndependentProgID"), String.Empty, progId, componentId);
+                        }
+
+                        this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat(progId, "\\CurVer"), String.Empty, parent, componentId);
+                    }
+                    else
+                    {
+                        if (YesNoType.Yes == firstProgIdForClass)
+                        {
+                            this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat("CLSID\\", classId, "\\ProgID"), String.Empty, progId, componentId);
+                        }
+                    }
+                }
+
+                if (null != icon)   // ProgId's Default Icon
+                {
+                    this.core.CreateSimpleReference(sourceLineNumbers, "File", icon);
+
+                    icon = String.Format(CultureInfo.InvariantCulture, "\"[#{0}]\"", icon);
+
+                    if (CompilerConstants.IntegerNotSet != iconIndex)
+                    {
+                        icon = String.Concat(icon, ",", iconIndex);
+                    }
+
+                    this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat(progId, "\\DefaultIcon"), String.Empty, icon, componentId);
+                }
+            }
+
+            if (null != noOpen)
+            {
+                this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, progId, "NoOpen", noOpen, componentId); // ProgId NoOpen name
+            }
+
+            // raise an error for an orphaned ProgId
+            if (YesNoType.Yes == advertise && !foundExtension && null == parent && null == classId)
+            {
+                this.core.OnMessage(WixWarnings.OrphanedProgId(sourceLineNumbers, progId));
+            }
+
+            return progId;
+        }
+
+        /// <summary>
+        /// Parses a property element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        private void ParsePropertyElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            bool admin = false;
+            bool complianceCheck = false;
+            bool hidden = false;
+            bool secure = false;
+            YesNoType suppressModularization = YesNoType.NotSet;
+            string value = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Admin":
+                            admin = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ComplianceCheck":
+                            complianceCheck = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Hidden":
+                            hidden = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Secure":
+                            secure = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "SuppressModularization":
+                            suppressModularization = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Value":
+                            value = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+                id = Identifier.Invalid;
+            }
+            else if ("ProductID" == id.Id)
+            {
+                this.core.OnMessage(WixWarnings.ProductIdAuthored(sourceLineNumbers));
+            }
+            else if ("SecureCustomProperties" == id.Id || "AdminProperties" == id.Id || "MsiHiddenProperties" == id.Id)
+            {
+                this.core.OnMessage(WixErrors.CannotAuthorSpecialProperties(sourceLineNumbers, id.Id));
+            }
+
+            string innerText = this.core.GetTrimmedInnerText(node);
+            if (null != value)
+            {
+                // cannot specify both the value attribute and inner text
+                if (!String.IsNullOrEmpty(innerText))
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeWithInnerText(sourceLineNumbers, node.Name.LocalName, "Value"));
+                }
+            }
+            else // value attribute not specified, use inner text if any.
+            {
+                value = innerText;
+            }
+
+            if ("ErrorDialog" == id.Id)
+            {
+                this.core.CreateSimpleReference(sourceLineNumbers, "Dialog", value);
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    {
+                        switch (child.Name.LocalName)
+                        {
+                            case "ProductSearch":
+                                this.ParseProductSearchElement(child, id.Id);
+                                secure = true;
+                                break;
+                            default:
+                                // let ParseSearchSignatures handle standard AppSearch children and unknown elements
+                                break;
+                        }
+                    }
+                }
+            }
+
+            // see if this property is used for appSearch
+            List<string> signatures = this.ParseSearchSignatures(node);
+
+            // If we're doing CCP then there must be a signature.
+            if (complianceCheck && 0 == signatures.Count)
+            {
+                this.core.OnMessage(WixErrors.SearchElementRequiredWithAttribute(sourceLineNumbers, node.Name.LocalName, "ComplianceCheck", "yes"));
+            }
+
+            foreach (string sig in signatures)
+            {
+                if (complianceCheck && !this.core.EncounteredError)
+                {
+                    this.core.CreateRow(sourceLineNumbers, "CCPSearch", new Identifier(sig, AccessModifier.Private));
+                }
+
+                this.AddAppSearch(sourceLineNumbers, id, sig);
+            }
+
+            // If we're doing AppSearch get that setup.
+            if (0 < signatures.Count)
+            {
+                this.AddProperty(sourceLineNumbers, id, value, admin, secure, hidden, false);
+            }
+            else // just a normal old property.
+            {
+                // If the property value is empty and none of the flags are set, print out a warning that we're ignoring
+                // the element.
+                if (String.IsNullOrEmpty(value) && !admin && !secure && !hidden)
+                {
+                    this.core.OnMessage(WixWarnings.PropertyUseless(sourceLineNumbers, id.Id));
+                }
+                else // there is a value and/or a flag set, do that.
+                {
+                    this.AddProperty(sourceLineNumbers, id, value, admin, secure, hidden, false);
+                }
+            }
+
+            if (!this.core.EncounteredError && YesNoType.Yes == suppressModularization)
+            {
+                this.core.OnMessage(WixWarnings.PropertyModularizationSuppressed(sourceLineNumbers));
+
+                this.core.CreateRow(sourceLineNumbers, "WixSuppressModularization", id);
+            }
+        }
+
+        /// <summary>
+        /// Parses a RegistryKey element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="componentId">Identifier for parent component.</param>
+        /// <param name="root">Root specified when element is nested under another Registry element, otherwise CompilerConstants.IntegerNotSet.</param>
+        /// <param name="parentKey">Parent key for this Registry element when nested.</param>
+        /// <param name="win64Component">true if the component is 64-bit.</param>
+        /// <param name="possibleKeyPath">Identifier of this registry key since it could be the component's keypath.</param>
+        /// <returns>Yes if this element was marked as the parent component's key path, No if explicitly marked as not being a key path, or NotSet otherwise.</returns>
+        [SuppressMessage("Microsoft.Globalization", "CA1308:NormalizeStringsToUppercase", Justification = "Changing the way this string normalizes would result " +
+                         "in a change to the way the Registry table is generated, potentially causing extra churn in patches on an MSI built from an older version of WiX. " +
+                         "Furthermore, there is no security hole here, as the strings won't need to make a round trip")]
+        private YesNoType ParseRegistryKeyElement(XElement node, string componentId, int root, string parentKey, bool win64Component, out string possibleKeyPath)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            string key = parentKey; // default to parent key path
+            string action = null;
+            bool forceCreateOnInstall = false;
+            bool forceDeleteOnUninstall = false;
+            Wix.RegistryKey.ActionType actionType = Wix.RegistryKey.ActionType.NotSet;
+            YesNoType keyPath = YesNoType.NotSet;
+
+            possibleKeyPath = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Action":
+                            this.core.OnMessage(WixWarnings.DeprecatedRegistryKeyActionAttribute(sourceLineNumbers));
+                            action = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (0 < action.Length)
+                            {
+                                actionType = Wix.RegistryKey.ParseActionType(action);
+                                switch (actionType)
+                                {
+                                    case Wix.RegistryKey.ActionType.create:
+                                        forceCreateOnInstall = true;
+                                        break;
+                                    case Wix.RegistryKey.ActionType.createAndRemoveOnUninstall:
+                                        forceCreateOnInstall = true;
+                                        forceDeleteOnUninstall = true;
+                                        break;
+                                    case Wix.RegistryKey.ActionType.none:
+                                        break;
+                                    default:
+                                        this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, action, "create", "createAndRemoveOnUninstall", "none"));
+                                        break;
+                                }
+                            }
+                            break;
+                        case "ForceCreateOnInstall":
+                            forceCreateOnInstall = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ForceDeleteOnUninstall":
+                            forceDeleteOnUninstall = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Key":
+                            key = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (null != parentKey)
+                            {
+                                key = Path.Combine(parentKey, key);
+                            }
+                            break;
+                        case "Root":
+                            if (CompilerConstants.IntegerNotSet != root)
+                            {
+                                this.core.OnMessage(WixErrors.RegistryRootInvalid(sourceLineNumbers));
+                            }
+
+                            root = this.core.GetAttributeMsidbRegistryRootValue(sourceLineNumbers, attrib, true);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            string name = forceCreateOnInstall ? (forceDeleteOnUninstall ? "*" : "+") : (forceDeleteOnUninstall ? "-" : null);
+
+            if (forceCreateOnInstall || forceDeleteOnUninstall) // generates a Registry row, so an Id must be present
+            {
+                // generate the identifier if it wasn't provided
+                if (null == id)
+                {
+                    id = this.core.CreateIdentifier("reg", componentId, root.ToString(CultureInfo.InvariantCulture.NumberFormat), LowercaseOrNull(key), LowercaseOrNull(name));
+                }
+            }
+            else // does not generate a Registry row, so no Id should be present
+            {
+                if (null != id)
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeWithoutOtherAttributes(sourceLineNumbers, node.Name.LocalName, "Id", "ForceCreateOnInstall", "ForceDeleteOnUninstall", "yes", true));
+                }
+            }
+
+            if (CompilerConstants.IntegerNotSet == root)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Root"));
+                root = CompilerConstants.IllegalInteger;
+            }
+
+            if (null == key)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Key"));
+                key = String.Empty; // set the key to something to prevent null reference exceptions
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    string possibleChildKeyPath = null;
+
+                    switch (child.Name.LocalName)
+                    {
+                        case "RegistryKey":
+                            if (YesNoType.Yes == this.ParseRegistryKeyElement(child, componentId, root, key, win64Component, out possibleChildKeyPath))
+                            {
+                                if (YesNoType.Yes == keyPath)
+                                {
+                                    this.core.OnMessage(WixErrors.ComponentMultipleKeyPaths(sourceLineNumbers, child.Name.LocalName, "KeyPath", "yes", "File", "RegistryValue", "ODBCDataSource"));
+                                }
+
+                                possibleKeyPath = possibleChildKeyPath; // the child is the key path
+                                keyPath = YesNoType.Yes;
+                            }
+                            else if (null == possibleKeyPath && null != possibleChildKeyPath)
+                            {
+                                possibleKeyPath = possibleChildKeyPath;
+                            }
+                            break;
+                        case "RegistryValue":
+                            if (YesNoType.Yes == this.ParseRegistryValueElement(child, componentId, root, key, win64Component, out possibleChildKeyPath))
+                            {
+                                if (YesNoType.Yes == keyPath)
+                                {
+                                    this.core.OnMessage(WixErrors.ComponentMultipleKeyPaths(sourceLineNumbers, child.Name.LocalName, "KeyPath", "yes", "File", "RegistryValue", "ODBCDataSource"));
+                                }
+
+                                possibleKeyPath = possibleChildKeyPath; // the child is the key path
+                                keyPath = YesNoType.Yes;
+                            }
+                            else if (null == possibleKeyPath && null != possibleChildKeyPath)
+                            {
+                                possibleKeyPath = possibleChildKeyPath;
+                            }
+                            break;
+                        case "Permission":
+                            if (!forceCreateOnInstall)
+                            {
+                                this.core.OnMessage(WixErrors.UnexpectedElementWithAttributeValue(sourceLineNumbers, node.Name.LocalName, child.Name.LocalName, "ForceCreateOnInstall", "yes"));
+                            }
+                            this.ParsePermissionElement(child, id.Id, "Registry");
+                            break;
+                        case "PermissionEx":
+                            if (!forceCreateOnInstall)
+                            {
+                                this.core.OnMessage(WixErrors.UnexpectedElementWithAttributeValue(sourceLineNumbers, node.Name.LocalName, child.Name.LocalName, "ForceCreateOnInstall", "yes"));
+                            }
+                            this.ParsePermissionExElement(child, id.Id, "Registry");
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    Dictionary<string, string> context = new Dictionary<string, string>() { { "RegistryId", id.Id }, { "ComponentId", componentId }, { "Win64", win64Component.ToString() } };
+                    this.core.ParseExtensionElement(node, child, context);
+                }
+            }
+
+
+            if (!this.core.EncounteredError && null != name)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "Registry", id);
+                row[1] = root;
+                row[2] = key;
+                row[3] = name;
+                row[4] = null;
+                row[5] = componentId;
+            }
+
+            return keyPath;
+        }
+
+        /// <summary>
+        /// Parses a RegistryValue element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="componentId">Identifier for parent component.</param>
+        /// <param name="root">Root specified when element is nested under a RegistryKey element, otherwise CompilerConstants.IntegerNotSet.</param>
+        /// <param name="parentKey">Root specified when element is nested under a RegistryKey element, otherwise CompilerConstants.IntegerNotSet.</param>
+        /// <param name="win64Component">true if the component is 64-bit.</param>
+        /// <param name="possibleKeyPath">Identifier of this registry key since it could be the component's keypath.</param>
+        /// <returns>Yes if this element was marked as the parent component's key path, No if explicitly marked as not being a key path, or NotSet otherwise.</returns>
+        [SuppressMessage("Microsoft.Globalization", "CA1308:NormalizeStringsToUppercase", Justification = "Changing the way this string normalizes would result " +
+                         "in a change to the way the Registry table is generated, potentially causing extra churn in patches on an MSI built from an older version of WiX. " +
+                         "Furthermore, there is no security hole here, as the strings won't need to make a round trip")]
+        private YesNoType ParseRegistryValueElement(XElement node, string componentId, int root, string parentKey, bool win64Component, out string possibleKeyPath)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            string key = parentKey; // default to parent key path
+            string name = null;
+            string value = null;
+            string type = null;
+            Wix.RegistryValue.TypeType typeType = Wix.RegistryValue.TypeType.NotSet;
+            string action = null;
+            Wix.RegistryValue.ActionType actionType = Wix.RegistryValue.ActionType.NotSet;
+            YesNoType keyPath = YesNoType.NotSet;
+            bool couldBeKeyPath = true; // assume that this is a regular registry key that could become the key path
+
+            possibleKeyPath = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Action":
+                            action = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (0 < action.Length)
+                            {
+                                if (!Wix.RegistryValue.TryParseActionType(action, out actionType))
+                                {
+                                    this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, action, "append", "prepend", "write"));
+                                }
+                            }
+                            break;
+                        case "Key":
+                            key = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (null != parentKey)
+                            {
+                                if (parentKey.EndsWith("\\", StringComparison.Ordinal))
+                                {
+                                    key = String.Concat(parentKey, key);
+                                }
+                                else
+                                {
+                                    key = String.Concat(parentKey, "\\", key);
+                                }
+                            }
+                            break;
+                        case "KeyPath":
+                            keyPath = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Name":
+                            name = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Root":
+                            if (CompilerConstants.IntegerNotSet != root)
+                            {
+                                this.core.OnMessage(WixErrors.RegistryRootInvalid(sourceLineNumbers));
+                            }
+
+                            root = this.core.GetAttributeMsidbRegistryRootValue(sourceLineNumbers, attrib, true);
+                            break;
+                        case "Type":
+                            type = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (0 < type.Length)
+                            {
+                                if (!Wix.RegistryValue.TryParseTypeType(type, out typeType))
+                                {
+                                    this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, type, "binary", "expandable", "integer", "multiString", "string"));
+                                }
+                            }
+                            break;
+                        case "Value":
+                            value = this.core.GetAttributeValue(sourceLineNumbers, attrib, EmptyRule.CanBeEmpty);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            // generate the identifier if it wasn't provided
+            if (null == id)
+            {
+                id = this.core.CreateIdentifier("reg", componentId, root.ToString(CultureInfo.InvariantCulture.NumberFormat), LowercaseOrNull(key), LowercaseOrNull(name));
+            }
+
+            if ((Wix.RegistryValue.ActionType.append == actionType || Wix.RegistryValue.ActionType.prepend == actionType) &&
+                Wix.RegistryValue.TypeType.multiString != typeType)
+            {
+                this.core.OnMessage(WixErrors.IllegalAttributeValueWithoutOtherAttribute(sourceLineNumbers, node.Name.LocalName, "Action", action, "Type", "multiString"));
+            }
+
+            if (null == key)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Key"));
+            }
+
+            if (CompilerConstants.IntegerNotSet == root)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Root"));
+            }
+
+            if (null == type)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Type"));
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "MultiStringValue":
+                            if (Wix.RegistryValue.TypeType.multiString != typeType && null != value)
+                            {
+                                this.core.OnMessage(WixErrors.RegistryMultipleValuesWithoutMultiString(sourceLineNumbers, node.Name.LocalName, "Value", child.Name.LocalName, "Type"));
+                            }
+                            else if (null == value)
+                            {
+                                value = Common.GetInnerText(child);
+                            }
+                            else
+                            {
+                                value = String.Concat(value, "[~]", Common.GetInnerText(child));
+                            }
+                            break;
+                        case "Permission":
+                            this.ParsePermissionElement(child, id.Id, "Registry");
+                            break;
+                        case "PermissionEx":
+                            this.ParsePermissionExElement(child, id.Id, "Registry");
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    Dictionary<string, string> context = new Dictionary<string, string>() { { "RegistryId", id.Id }, { "ComponentId", componentId }, { "Win64", win64Component.ToString() } };
+                    this.core.ParseExtensionElement(node, child, context);
+                }
+            }
+
+
+            switch (typeType)
+            {
+                case Wix.RegistryValue.TypeType.binary:
+                    value = String.Concat("#x", value);
+                    break;
+                case Wix.RegistryValue.TypeType.expandable:
+                    value = String.Concat("#%", value);
+                    break;
+                case Wix.RegistryValue.TypeType.integer:
+                    value = String.Concat("#", value);
+                    break;
+                case Wix.RegistryValue.TypeType.multiString:
+                    switch (actionType)
+                    {
+                        case Wix.RegistryValue.ActionType.append:
+                            value = String.Concat("[~]", value);
+                            break;
+                        case Wix.RegistryValue.ActionType.prepend:
+                            value = String.Concat(value, "[~]");
+                            break;
+                        case Wix.RegistryValue.ActionType.write:
+                        default:
+                            if (null != value && -1 == value.IndexOf("[~]", StringComparison.Ordinal))
+                            {
+                                value = String.Format(CultureInfo.InvariantCulture, "[~]{0}[~]", value);
+                            }
+                            break;
+                    }
+                    break;
+                case Wix.RegistryValue.TypeType.@string:
+                    // escape the leading '#' character for string registry keys
+                    if (null != value && value.StartsWith("#", StringComparison.Ordinal))
+                    {
+                        value = String.Concat("#", value);
+                    }
+                    break;
+            }
+
+            // value may be set by child MultiStringValue elements, so it must be checked here
+            if (null == value)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Value"));
+            }
+            else if (0 == value.Length && ("+" == name || "-" == name || "*" == name)) // prevent accidental authoring of special name values
+            {
+                this.core.OnMessage(WixErrors.RegistryNameValueIncorrect(sourceLineNumbers, node.Name.LocalName, "Name", name));
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "Registry", id);
+                row[1] = root;
+                row[2] = key;
+                row[3] = name;
+                row[4] = value;
+                row[5] = componentId;
+            }
+
+            // If this was just a regular registry key (that could be the key path)
+            // and no child registry key set the possible key path, let's make this
+            // Registry/@Id a possible key path.
+            if (couldBeKeyPath && null == possibleKeyPath)
+            {
+                possibleKeyPath = id.Id;
+            }
+
+            return keyPath;
+        }
+
+        /// <summary>
+        /// Parses a RemoveRegistryKey element.
+        /// </summary>
+        /// <param name="node">The element to parse.</param>
+        /// <param name="componentId">The component identifier of the parent element.</param>
+        [SuppressMessage("Microsoft.Globalization", "CA1308:NormalizeStringsToUppercase", Justification = "Changing the way this string normalizes would result " +
+                         "in a change to the way the Registry table is generated, potentially causing extra churn in patches on an MSI built from an older version of WiX. " +
+                         "Furthermore, there is no security hole here, as the strings won't need to make a round trip")]
+        private void ParseRemoveRegistryKeyElement(XElement node, string componentId)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            string action = null;
+            Wix.RemoveRegistryKey.ActionType actionType = Wix.RemoveRegistryKey.ActionType.NotSet;
+            string key = null;
+            string name = "-";
+            int root = CompilerConstants.IntegerNotSet;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Action":
+                            action = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (0 < action.Length)
+                            {
+                                if (!Wix.RemoveRegistryKey.TryParseActionType(action, out actionType))
+                                {
+                                    this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, action, "removeOnInstall", "removeOnUninstall"));
+                                }
+                            }
+                            break;
+                        case "Key":
+                            key = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Root":
+                            root = this.core.GetAttributeMsidbRegistryRootValue(sourceLineNumbers, attrib, true);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            // generate the identifier if it wasn't provided
+            if (null == id)
+            {
+                id = this.core.CreateIdentifier("reg", componentId, root.ToString(CultureInfo.InvariantCulture.NumberFormat), LowercaseOrNull(key), LowercaseOrNull(name));
+            }
+
+            if (null == action)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Action"));
+            }
+
+            if (null == key)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Key"));
+            }
+
+            if (CompilerConstants.IntegerNotSet == root)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Root"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, (Wix.RemoveRegistryKey.ActionType.removeOnUninstall == actionType ? "Registry" : "RemoveRegistry"), id);
+                row[1] = root;
+                row[2] = key;
+                row[3] = name;
+                if (Wix.RemoveRegistryKey.ActionType.removeOnUninstall == actionType) // Registry table
+                {
+                    row[4] = null;
+                    row[5] = componentId;
+                }
+                else // RemoveRegistry table
+                {
+                    row[4] = componentId;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses a RemoveRegistryValue element.
+        /// </summary>
+        /// <param name="node">The element to parse.</param>
+        /// <param name="componentId">The component identifier of the parent element.</param>
+        [SuppressMessage("Microsoft.Globalization", "CA1308:NormalizeStringsToUppercase", Justification = "Changing the way this string normalizes would result " +
+                         "in a change to the way the Registry table is generated, potentially causing extra churn in patches on an MSI built from an older version of WiX. " +
+                         "Furthermore, there is no security hole here, as the strings won't need to make a round trip")]
+        private void ParseRemoveRegistryValueElement(XElement node, string componentId)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            string key = null;
+            string name = null;
+            int root = CompilerConstants.IntegerNotSet;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Key":
+                            key = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Name":
+                            name = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Root":
+                            root = this.core.GetAttributeMsidbRegistryRootValue(sourceLineNumbers, attrib, true);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            // generate the identifier if it wasn't provided
+            if (null == id)
+            {
+                id = this.core.CreateIdentifier("reg", componentId, root.ToString(CultureInfo.InvariantCulture.NumberFormat), LowercaseOrNull(key), LowercaseOrNull(name));
+            }
+
+            if (null == key)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Key"));
+            }
+
+            if (CompilerConstants.IntegerNotSet == root)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Root"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "RemoveRegistry", id);
+                row[1] = root;
+                row[2] = key;
+                row[3] = name;
+                row[4] = componentId;
+            }
+        }
+
+        /// <summary>
+        /// Parses a remove file element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="componentId">Identifier of parent component.</param>
+        /// <param name="parentDirectory">Identifier of the parent component's directory.</param>
+        private void ParseRemoveFileElement(XElement node, string componentId, string parentDirectory)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            string directory = null;
+            string name = null;
+            int on = CompilerConstants.IntegerNotSet;
+            string property = null;
+            string shortName = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Directory":
+                            directory = this.core.CreateDirectoryReferenceFromInlineSyntax(sourceLineNumbers, attrib, parentDirectory);
+                            break;
+                        case "Name":
+                            name = this.core.GetAttributeLongFilename(sourceLineNumbers, attrib, true);
+                            break;
+                        case "On":
+                            Wix.InstallUninstallType onValue = this.core.GetAttributeInstallUninstallValue(sourceLineNumbers, attrib);
+                            switch (onValue)
+                            {
+                                case Wix.InstallUninstallType.install:
+                                    on = 1;
+                                    break;
+                                case Wix.InstallUninstallType.uninstall:
+                                    on = 2;
+                                    break;
+                                case Wix.InstallUninstallType.both:
+                                    on = 3;
+                                    break;
+                                default:
+                                    on = CompilerConstants.IllegalInteger;
+                                    break;
+                            }
+                            break;
+                        case "Property":
+                            property = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ShortName":
+                            shortName = this.core.GetAttributeShortFilename(sourceLineNumbers, attrib, true);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == name)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Name"));
+            }
+            else if (0 < name.Length)
+            {
+                if (this.core.IsValidShortFilename(name, true))
+                {
+                    if (null == shortName)
+                    {
+                        shortName = name;
+                        name = null;
+                    }
+                    else
+                    {
+                        this.core.OnMessage(WixErrors.IllegalAttributeValueWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "Name", name, "ShortName"));
+                    }
+                }
+                else if (null == shortName) // generate a short file name.
+                {
+                    shortName = this.core.CreateShortName(name, true, true, node.Name.LocalName, componentId);
+                }
+            }
+
+            if (CompilerConstants.IntegerNotSet == on)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "On"));
+                on = CompilerConstants.IllegalInteger;
+            }
+
+            if (null != directory && null != property)
+            {
+                this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "Property", "Directory", directory));
+            }
+
+            if (null == id)
+            {
+                id = this.core.CreateIdentifier("rmf", directory ?? property ?? parentDirectory, LowercaseOrNull(shortName), LowercaseOrNull(name), on.ToString());
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "RemoveFile", id);
+                row[1] = componentId;
+                row[2] = GetMsiFilenameValue(shortName, name);
+                if (null != directory)
+                {
+                    row[3] = directory;
+                }
+                else if (null != property)
+                {
+                    row[3] = property;
+                }
+                else
+                {
+                    row[3] = parentDirectory;
+                }
+                row[4] = on;
+            }
+        }
+
+        /// <summary>
+        /// Parses a RemoveFolder element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="componentId">Identifier of parent component.</param>
+        /// <param name="parentDirectory">Identifier of parent component's directory.</param>
+        private void ParseRemoveFolderElement(XElement node, string componentId, string parentDirectory)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            string directory = null;
+            int on = CompilerConstants.IntegerNotSet;
+            string property = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Directory":
+                            directory = this.core.CreateDirectoryReferenceFromInlineSyntax(sourceLineNumbers, attrib, parentDirectory);
+                            break;
+                        case "On":
+                            Wix.InstallUninstallType onValue = this.core.GetAttributeInstallUninstallValue(sourceLineNumbers, attrib);
+                            switch (onValue)
+                            {
+                                case Wix.InstallUninstallType.install:
+                                    on = 1;
+                                    break;
+                                case Wix.InstallUninstallType.uninstall:
+                                    on = 2;
+                                    break;
+                                case Wix.InstallUninstallType.both:
+                                    on = 3;
+                                    break;
+                                default:
+                                    on = CompilerConstants.IllegalInteger;
+                                    break;
+                            }
+                            break;
+                        case "Property":
+                            property = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (CompilerConstants.IntegerNotSet == on)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "On"));
+                on = CompilerConstants.IllegalInteger;
+            }
+
+            if (null != directory && null != property)
+            {
+                this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "Property", "Directory", directory));
+            }
+
+            if (null == id)
+            {
+                id = this.core.CreateIdentifier("rmf", directory ?? property ?? parentDirectory, on.ToString());
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "RemoveFile", id);
+                row[1] = componentId;
+                row[2] = null;
+                if (null != directory)
+                {
+                    row[3] = directory;
+                }
+                else if (null != property)
+                {
+                    row[3] = property;
+                }
+                else
+                {
+                    row[3] = parentDirectory;
+                }
+                row[4] = on;
+            }
+        }
+
+        /// <summary>
+        /// Parses a reserve cost element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="componentId">Identifier of parent component.</param>
+        /// <param name="directoryId">Optional and default identifier of referenced directory.</param>
+        private void ParseReserveCostElement(XElement node, string componentId, string directoryId)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            int runFromSource = CompilerConstants.IntegerNotSet;
+            int runLocal = CompilerConstants.IntegerNotSet;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Directory":
+                            directoryId = this.core.CreateDirectoryReferenceFromInlineSyntax(sourceLineNumbers, attrib, directoryId);
+                            break;
+                        case "RunFromSource":
+                            runFromSource = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, int.MaxValue);
+                            break;
+                        case "RunLocal":
+                            runLocal = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, int.MaxValue);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                id = this.core.CreateIdentifier("rc", componentId, directoryId);
+            }
+
+            if (CompilerConstants.IntegerNotSet == runFromSource)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "RunFromSource"));
+            }
+
+            if (CompilerConstants.IntegerNotSet == runLocal)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "RunLocal"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "ReserveCost", id);
+                row[1] = componentId;
+                row[2] = directoryId;
+                row[3] = runLocal;
+                row[4] = runFromSource;
+            }
+        }
+
+        /// <summary>
+        /// Parses a sequence element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="sequenceTable">Name of sequence table.</param>
+        private void ParseSequenceElement(XElement node, string sequenceTable)
+        {
+            // use the proper table name internally
+            if ("AdvertiseExecuteSequence" == sequenceTable)
+            {
+                sequenceTable = "AdvtExecuteSequence";
+            }
+
+            // Parse each action in the sequence.
+            foreach (XElement child in node.Elements())
+            {
+                SourceLineNumber childSourceLineNumbers = Preprocessor.GetSourceLineNumbers(child);
+                string actionName = child.Name.LocalName;
+                string afterAction = null;
+                string beforeAction = null;
+                string condition = null;
+                bool customAction = "Custom" == actionName;
+                bool overridable = false;
+                int exitSequence = CompilerConstants.IntegerNotSet;
+                int sequence = CompilerConstants.IntegerNotSet;
+                bool showDialog = "Show" == actionName;
+                bool specialAction = "InstallExecute" == actionName || "InstallExecuteAgain" == actionName || "RemoveExistingProducts" == actionName || "DisableRollback" == actionName || "ScheduleReboot" == actionName || "ForceReboot" == actionName || "ResolveSource" == actionName;
+                bool specialStandardAction = "AppSearch" == actionName || "CCPSearch" == actionName || "RMCCPSearch" == actionName || "LaunchConditions" == actionName || "FindRelatedProducts" == actionName;
+                bool suppress = false;
+
+                foreach (XAttribute attrib in child.Attributes())
+                {
+                    if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                    {
+                        switch (attrib.Name.LocalName)
+                        {
+                            case "Action":
+                                if (customAction)
+                                {
+                                    actionName = this.core.GetAttributeIdentifierValue(childSourceLineNumbers, attrib);
+                                    this.core.CreateSimpleReference(childSourceLineNumbers, "CustomAction", actionName);
+                                }
+                                else
+                                {
+                                    this.core.UnexpectedAttribute(child, attrib);
+                                }
+                                break;
+                            case "After":
+                                if (customAction || showDialog || specialAction || specialStandardAction)
+                                {
+                                    afterAction = this.core.GetAttributeIdentifierValue(childSourceLineNumbers, attrib);
+                                    this.core.CreateSimpleReference(childSourceLineNumbers, "WixAction", sequenceTable, afterAction);
+                                }
+                                else
+                                {
+                                    this.core.UnexpectedAttribute(child, attrib);
+                                }
+                                break;
+                            case "Before":
+                                if (customAction || showDialog || specialAction || specialStandardAction)
+                                {
+                                    beforeAction = this.core.GetAttributeIdentifierValue(childSourceLineNumbers, attrib);
+                                    this.core.CreateSimpleReference(childSourceLineNumbers, "WixAction", sequenceTable, beforeAction);
+                                }
+                                else
+                                {
+                                    this.core.UnexpectedAttribute(child, attrib);
+                                }
+                                break;
+                            case "Dialog":
+                                if (showDialog)
+                                {
+                                    actionName = this.core.GetAttributeIdentifierValue(childSourceLineNumbers, attrib);
+                                    this.core.CreateSimpleReference(childSourceLineNumbers, "Dialog", actionName);
+                                }
+                                else
+                                {
+                                    this.core.UnexpectedAttribute(child, attrib);
+                                }
+                                break;
+                            case "OnExit":
+                                if (customAction || showDialog || specialAction)
+                                {
+                                    Wix.ExitType exitValue = this.core.GetAttributeExitValue(childSourceLineNumbers, attrib);
+                                    switch (exitValue)
+                                    {
+                                        case Wix.ExitType.success:
+                                            exitSequence = -1;
+                                            break;
+                                        case Wix.ExitType.cancel:
+                                            exitSequence = -2;
+                                            break;
+                                        case Wix.ExitType.error:
+                                            exitSequence = -3;
+                                            break;
+                                        case Wix.ExitType.suspend:
+                                            exitSequence = -4;
+                                            break;
+                                    }
+                                }
+                                else
+                                {
+                                    this.core.UnexpectedAttribute(child, attrib);
+                                }
+                                break;
+                            case "Overridable":
+                                overridable = YesNoType.Yes == this.core.GetAttributeYesNoValue(childSourceLineNumbers, attrib);
+                                break;
+                            case "Sequence":
+                                sequence = this.core.GetAttributeIntegerValue(childSourceLineNumbers, attrib, 1, short.MaxValue);
+                                break;
+                            case "Suppress":
+                                suppress = YesNoType.Yes == this.core.GetAttributeYesNoValue(childSourceLineNumbers, attrib);
+                                break;
+                            default:
+                                this.core.UnexpectedAttribute(node, attrib);
+                                break;
+                        }
+                    }
+                    else
+                    {
+                        this.core.ParseExtensionAttribute(node, attrib);
+                    }
+                }
+
+
+                // Get the condition from the inner text of the element.
+                condition = this.core.GetConditionInnerText(child);
+
+                if (customAction && "Custom" == actionName)
+                {
+                    this.core.OnMessage(WixErrors.ExpectedAttribute(childSourceLineNumbers, child.Name.LocalName, "Action"));
+                }
+                else if (showDialog && "Show" == actionName)
+                {
+                    this.core.OnMessage(WixErrors.ExpectedAttribute(childSourceLineNumbers, child.Name.LocalName, "Dialog"));
+                }
+
+                if (CompilerConstants.IntegerNotSet != sequence)
+                {
+                    if (CompilerConstants.IntegerNotSet != exitSequence)
+                    {
+                        this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(childSourceLineNumbers, child.Name.LocalName, "Sequence", "OnExit"));
+                    }
+                    else if (null != beforeAction || null != afterAction)
+                    {
+                        this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(childSourceLineNumbers, child.Name.LocalName, "Sequence", "Before", "After"));
+                    }
+                }
+                else // sequence not specified use OnExit (which may also be not set).
+                {
+                    sequence = exitSequence;
+                }
+
+                if (null != beforeAction && null != afterAction)
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(childSourceLineNumbers, child.Name.LocalName, "After", "Before"));
+                }
+                else if ((customAction || showDialog || specialAction) && !suppress && CompilerConstants.IntegerNotSet == sequence && null == beforeAction && null == afterAction)
+                {
+                    this.core.OnMessage(WixErrors.NeedSequenceBeforeOrAfter(childSourceLineNumbers, child.Name.LocalName));
+                }
+
+                // action that is scheduled to occur before/after itself
+                if (beforeAction == actionName)
+                {
+                    this.core.OnMessage(WixErrors.ActionScheduledRelativeToItself(childSourceLineNumbers, child.Name.LocalName, "Before", beforeAction));
+                }
+                else if (afterAction == actionName)
+                {
+                    this.core.OnMessage(WixErrors.ActionScheduledRelativeToItself(childSourceLineNumbers, child.Name.LocalName, "After", afterAction));
+                }
+
+                // normal standard actions cannot be set overridable by the user (since they are overridable by default)
+                if (overridable && WindowsInstallerStandard.IsStandardAction(actionName) && !specialAction)
+                {
+                    this.core.OnMessage(WixErrors.UnexpectedAttribute(childSourceLineNumbers, child.Name.LocalName, "Overridable"));
+                }
+
+                // suppress cannot be specified at the same time as Before, After, or Sequence
+                if (suppress && (null != afterAction || null != beforeAction || CompilerConstants.IntegerNotSet != sequence || overridable))
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttributes(childSourceLineNumbers, child.Name.LocalName, "Suppress", "Before", "After", "Sequence", "Overridable"));
+                }
+
+                this.core.ParseForExtensionElements(child);
+
+                // add the row and any references needed
+                if (!this.core.EncounteredError)
+                {
+                    if (suppress)
+                    {
+                        Row row = this.core.CreateRow(childSourceLineNumbers, "WixSuppressAction");
+                        row[0] = sequenceTable;
+                        row[1] = actionName;
+                    }
+                    else
+                    {
+                        Row row = this.core.CreateRow(childSourceLineNumbers, "WixAction");
+                        row[0] = sequenceTable;
+                        row[1] = actionName;
+                        row[2] = condition;
+                        if (CompilerConstants.IntegerNotSet != sequence)
+                        {
+                            row[3] = sequence;
+                        }
+                        row[4] = beforeAction;
+                        row[5] = afterAction;
+                        row[6] = overridable ? 1 : 0;
+                    }
+                }
+            }
+        }
+
+
+        /// <summary>
+        /// Parses a service config element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="componentId">Identifier of parent component.</param>
+        /// <param name="serviceName">Optional element containing parent's service name.</param>
+        private void ParseServiceConfigElement(XElement node, string componentId, string serviceName)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            string delayedAutoStart = null;
+            string failureActionsWhen = null;
+            int events = 0;
+            string name = serviceName;
+            string preShutdownDelay = null;
+            string requiredPrivileges = null;
+            string sid = null;
+
+            this.core.OnMessage(WixWarnings.ServiceConfigFamilyNotSupported(sourceLineNumbers, node.Name.LocalName));
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "DelayedAutoStart":
+                            delayedAutoStart = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (0 < delayedAutoStart.Length)
+                            {
+                                switch (delayedAutoStart)
+                                {
+                                    case "no":
+                                        delayedAutoStart = "0";
+                                        break;
+                                    case "yes":
+                                        delayedAutoStart = "1";
+                                        break;
+                                    default:
+                                        // allow everything else to pass through that are hopefully "formatted" Properties.
+                                        break;
+                                }
+                            }
+                            break;
+                        case "FailureActionsWhen":
+                            failureActionsWhen = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (0 < failureActionsWhen.Length)
+                            {
+                                switch (failureActionsWhen)
+                                {
+                                    case "failedToStop":
+                                        failureActionsWhen = "0";
+                                        break;
+                                    case "failedToStopOrReturnedError":
+                                        failureActionsWhen = "1";
+                                        break;
+                                    default:
+                                        // allow everything else to pass through that are hopefully "formatted" Properties.
+                                        break;
+                                }
+                            }
+                            break;
+                        case "OnInstall":
+                            YesNoType install = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            if (YesNoType.Yes == install)
+                            {
+                                events |= MsiInterop.MsidbServiceConfigEventInstall;
+                            }
+                            break;
+                        case "OnReinstall":
+                            YesNoType reinstall = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            if (YesNoType.Yes == reinstall)
+                            {
+                                events |= MsiInterop.MsidbServiceConfigEventReinstall;
+                            }
+                            break;
+                        case "OnUninstall":
+                            YesNoType uninstall = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            if (YesNoType.Yes == uninstall)
+                            {
+                                events |= MsiInterop.MsidbServiceConfigEventUninstall;
+                            }
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                        case "PreShutdownDelay":
+                            preShutdownDelay = this.core.GetAttributeValue(sourceLineNumbers, attrib, EmptyRule.CanBeEmpty);
+                            break;
+                        case "ServiceName":
+                            if (!String.IsNullOrEmpty(serviceName))
+                            {
+                                this.core.OnMessage(WixErrors.IllegalAttributeWhenNested(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, "ServiceInstall"));
+                            }
+
+                            name = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ServiceSid":
+                            sid = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (0 < sid.Length)
+                            {
+                                switch (sid)
+                                {
+                                    case "none":
+                                        sid = "0";
+                                        break;
+                                    case "restricted":
+                                        sid = "3";
+                                        break;
+                                    case "unrestricted":
+                                        sid = "1";
+                                        break;
+                                    default:
+                                        // allow everything else to pass through that are hopefully "formatted" Properties.
+                                        break;
+                                }
+                            }
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            // Get the ServiceConfig required privilegs.
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "RequiredPrivilege":
+                            string privilege = this.core.GetTrimmedInnerText(child);
+                            switch (privilege)
+                            {
+                                case "assignPrimaryToken":
+                                    privilege = "SeAssignPrimaryTokenPrivilege";
+                                    break;
+                                case "audit":
+                                    privilege = "SeAuditPrivilege";
+                                    break;
+                                case "backup":
+                                    privilege = "SeBackupPrivilege";
+                                    break;
+                                case "changeNotify":
+                                    privilege = "SeChangeNotifyPrivilege";
+                                    break;
+                                case "createGlobal":
+                                    privilege = "SeCreateGlobalPrivilege";
+                                    break;
+                                case "createPagefile":
+                                    privilege = "SeCreatePagefilePrivilege";
+                                    break;
+                                case "createPermanent":
+                                    privilege = "SeCreatePermanentPrivilege";
+                                    break;
+                                case "createSymbolicLink":
+                                    privilege = "SeCreateSymbolicLinkPrivilege";
+                                    break;
+                                case "createToken":
+                                    privilege = "SeCreateTokenPrivilege";
+                                    break;
+                                case "debug":
+                                    privilege = "SeDebugPrivilege";
+                                    break;
+                                case "enableDelegation":
+                                    privilege = "SeEnableDelegationPrivilege";
+                                    break;
+                                case "impersonate":
+                                    privilege = "SeImpersonatePrivilege";
+                                    break;
+                                case "increaseBasePriority":
+                                    privilege = "SeIncreaseBasePriorityPrivilege";
+                                    break;
+                                case "increaseQuota":
+                                    privilege = "SeIncreaseQuotaPrivilege";
+                                    break;
+                                case "increaseWorkingSet":
+                                    privilege = "SeIncreaseWorkingSetPrivilege";
+                                    break;
+                                case "loadDriver":
+                                    privilege = "SeLoadDriverPrivilege";
+                                    break;
+                                case "lockMemory":
+                                    privilege = "SeLockMemoryPrivilege";
+                                    break;
+                                case "machineAccount":
+                                    privilege = "SeMachineAccountPrivilege";
+                                    break;
+                                case "manageVolume":
+                                    privilege = "SeManageVolumePrivilege";
+                                    break;
+                                case "profileSingleProcess":
+                                    privilege = "SeProfileSingleProcessPrivilege";
+                                    break;
+                                case "relabel":
+                                    privilege = "SeRelabelPrivilege";
+                                    break;
+                                case "remoteShutdown":
+                                    privilege = "SeRemoteShutdownPrivilege";
+                                    break;
+                                case "restore":
+                                    privilege = "SeRestorePrivilege";
+                                    break;
+                                case "security":
+                                    privilege = "SeSecurityPrivilege";
+                                    break;
+                                case "shutdown":
+                                    privilege = "SeShutdownPrivilege";
+                                    break;
+                                case "syncAgent":
+                                    privilege = "SeSyncAgentPrivilege";
+                                    break;
+                                case "systemEnvironment":
+                                    privilege = "SeSystemEnvironmentPrivilege";
+                                    break;
+                                case "systemProfile":
+                                    privilege = "SeSystemProfilePrivilege";
+                                    break;
+                                case "systemTime":
+                                case "modifySystemTime":
+                                    privilege = "SeSystemtimePrivilege";
+                                    break;
+                                case "takeOwnership":
+                                    privilege = "SeTakeOwnershipPrivilege";
+                                    break;
+                                case "tcb":
+                                case "trustedComputerBase":
+                                    privilege = "SeTcbPrivilege";
+                                    break;
+                                case "timeZone":
+                                case "modifyTimeZone":
+                                    privilege = "SeTimeZonePrivilege";
+                                    break;
+                                case "trustedCredManAccess":
+                                case "trustedCredentialManagerAccess":
+                                    privilege = "SeTrustedCredManAccessPrivilege";
+                                    break;
+                                case "undock":
+                                    privilege = "SeUndockPrivilege";
+                                    break;
+                                case "unsolicitedInput":
+                                    privilege = "SeUnsolicitedInputPrivilege";
+                                    break;
+                                default:
+                                    // allow everything else to pass through that are hopefully "formatted" Properties.
+                                    break;
+                            }
+
+                            if (null != requiredPrivileges)
+                            {
+                                requiredPrivileges = String.Concat(requiredPrivileges, "[~]");
+                            }
+                            requiredPrivileges = String.Concat(requiredPrivileges, privilege);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (String.IsNullOrEmpty(name))
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "ServiceName"));
+            }
+            else if (null == id)
+            {
+                id = this.core.CreateIdentifierFromFilename(name);
+            }
+
+            if (0 == events)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttributes(sourceLineNumbers, node.Name.LocalName, "OnInstall", "OnReinstall", "OnUninstall"));
+            }
+
+            if (String.IsNullOrEmpty(delayedAutoStart) && String.IsNullOrEmpty(failureActionsWhen) && String.IsNullOrEmpty(preShutdownDelay) && String.IsNullOrEmpty(requiredPrivileges) && String.IsNullOrEmpty(sid))
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttributes(sourceLineNumbers, node.Name.LocalName, "DelayedAutoStart", "FailureActionsWhen", "PreShutdownDelay", "ServiceSid", "RequiredPrivilege"));
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                if (!String.IsNullOrEmpty(delayedAutoStart))
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "MsiServiceConfig", new Identifier(String.Concat(id.Id, ".DS"), id.Access));
+                    row[1] = name;
+                    row[2] = events;
+                    row[3] = 3;
+                    row[4] = delayedAutoStart;
+                    row[5] = componentId;
+                }
+
+                if (!String.IsNullOrEmpty(failureActionsWhen))
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "MsiServiceConfig", new Identifier(String.Concat(id.Id, ".FA"), id.Access));
+                    row[1] = name;
+                    row[2] = events;
+                    row[3] = 4;
+                    row[4] = failureActionsWhen;
+                    row[5] = componentId;
+                }
+
+                if (!String.IsNullOrEmpty(sid))
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "MsiServiceConfig", new Identifier(String.Concat(id.Id, ".SS"), id.Access));
+                    row[1] = name;
+                    row[2] = events;
+                    row[3] = 5;
+                    row[4] = sid;
+                    row[5] = componentId;
+                }
+
+                if (!String.IsNullOrEmpty(requiredPrivileges))
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "MsiServiceConfig", new Identifier(String.Concat(id.Id, ".RP"), id.Access));
+                    row[1] = name;
+                    row[2] = events;
+                    row[3] = 6;
+                    row[4] = requiredPrivileges;
+                    row[5] = componentId;
+                }
+
+                if (!String.IsNullOrEmpty(preShutdownDelay))
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "MsiServiceConfig", new Identifier(String.Concat(id.Id, ".PD"), id.Access));
+                    row[1] = name;
+                    row[2] = events;
+                    row[3] = 7;
+                    row[4] = preShutdownDelay;
+                    row[5] = componentId;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses a service config failure actions element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="componentId">Identifier of parent component.</param>
+        /// <param name="serviceName">Optional element containing parent's service name.</param>
+        private void ParseServiceConfigFailureActionsElement(XElement node, string componentId, string serviceName)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            int events = 0;
+            string name = serviceName;
+            int resetPeriod = CompilerConstants.IntegerNotSet;
+            string rebootMessage = null;
+            string command = null;
+            string actions = null;
+            string actionsDelays = null;
+
+            this.core.OnMessage(WixWarnings.ServiceConfigFamilyNotSupported(sourceLineNumbers, node.Name.LocalName));
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Command":
+                            command = this.core.GetAttributeValue(sourceLineNumbers, attrib, EmptyRule.CanBeEmpty);
+                            break;
+                        case "OnInstall":
+                            YesNoType install = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            if (YesNoType.Yes == install)
+                            {
+                                events |= MsiInterop.MsidbServiceConfigEventInstall;
+                            }
+                            break;
+                        case "OnReinstall":
+                            YesNoType reinstall = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            if (YesNoType.Yes == reinstall)
+                            {
+                                events |= MsiInterop.MsidbServiceConfigEventReinstall;
+                            }
+                            break;
+                        case "OnUninstall":
+                            YesNoType uninstall = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            if (YesNoType.Yes == uninstall)
+                            {
+                                events |= MsiInterop.MsidbServiceConfigEventUninstall;
+                            }
+                            break;
+                        case "RebootMessage":
+                            rebootMessage = this.core.GetAttributeValue(sourceLineNumbers, attrib, EmptyRule.CanBeEmpty);
+                            break;
+                        case "ResetPeriod":
+                            resetPeriod = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, int.MaxValue);
+                            break;
+                        case "ServiceName":
+                            if (!String.IsNullOrEmpty(serviceName))
+                            {
+                                this.core.OnMessage(WixErrors.IllegalAttributeWhenNested(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, "ServiceInstall"));
+                            }
+
+                            name = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            // Get the ServiceConfigFailureActions actions.
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "Failure":
+                            string action = null;
+                            string delay = null;
+                            SourceLineNumber childSourceLineNumbers = Preprocessor.GetSourceLineNumbers(child);
+
+                            foreach (XAttribute childAttrib in child.Attributes())
+                            {
+                                if (String.IsNullOrEmpty(childAttrib.Name.NamespaceName) || CompilerCore.WixNamespace == childAttrib.Name.Namespace)
+                                {
+                                    switch (childAttrib.Name.LocalName)
+                                    {
+                                        case "Action":
+                                            action = this.core.GetAttributeValue(childSourceLineNumbers, childAttrib);
+                                            switch (action)
+                                            {
+                                                case "none":
+                                                    action = "0";
+                                                    break;
+                                                case "restartComputer":
+                                                    action = "2";
+                                                    break;
+                                                case "restartService":
+                                                    action = "1";
+                                                    break;
+                                                case "runCommand":
+                                                    action = "3";
+                                                    break;
+                                                default:
+                                                    // allow everything else to pass through that are hopefully "formatted" Properties.
+                                                    break;
+                                            }
+                                            break;
+                                        case "Delay":
+                                            delay = this.core.GetAttributeValue(childSourceLineNumbers, childAttrib);
+                                            break;
+                                        default:
+                                            this.core.UnexpectedAttribute(child, childAttrib);
+                                            break;
+                                    }
+                                }
+                            }
+
+                            if (String.IsNullOrEmpty(action))
+                            {
+                                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, child.Name.LocalName, "Action"));
+                            }
+
+                            if (String.IsNullOrEmpty(delay))
+                            {
+                                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, child.Name.LocalName, "Delay"));
+                            }
+
+                            if (!String.IsNullOrEmpty(actions))
+                            {
+                                actions = String.Concat(actions, "[~]");
+                            }
+                            actions = String.Concat(actions, action);
+
+                            if (!String.IsNullOrEmpty(actionsDelays))
+                            {
+                                actionsDelays = String.Concat(actionsDelays, "[~]");
+                            }
+                            actionsDelays = String.Concat(actionsDelays, delay);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (String.IsNullOrEmpty(name))
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "ServiceName"));
+            }
+            else if (null == id)
+            {
+                id = this.core.CreateIdentifierFromFilename(name);
+            }
+
+            if (0 == events)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttributes(sourceLineNumbers, node.Name.LocalName, "OnInstall", "OnReinstall", "OnUninstall"));
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "MsiServiceConfigFailureActions", id);
+                row[1] = name;
+                row[2] = events;
+                if (CompilerConstants.IntegerNotSet != resetPeriod)
+                {
+                    row[3] = resetPeriod;
+                }
+                row[4] = rebootMessage ?? "[~]";
+                row[5] = command ?? "[~]";
+                row[6] = actions;
+                row[7] = actionsDelays;
+                row[8] = componentId;
+            }
+        }
+
+        /// <summary>
+        /// Parses a service control element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="componentId">Identifier of parent component.</param>
+        private void ParseServiceControlElement(XElement node, string componentId)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string arguments = null;
+            int events = 0; // default is to do nothing
+            Identifier id = null;
+            string name = null;
+            YesNoType wait = YesNoType.NotSet;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Name":
+                            name = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Remove":
+                            Wix.InstallUninstallType removeValue = this.core.GetAttributeInstallUninstallValue(sourceLineNumbers, attrib);
+                            switch (removeValue)
+                            {
+                                case Wix.InstallUninstallType.install:
+                                    events |= MsiInterop.MsidbServiceControlEventDelete;
+                                    break;
+                                case Wix.InstallUninstallType.uninstall:
+                                    events |= MsiInterop.MsidbServiceControlEventUninstallDelete;
+                                    break;
+                                case Wix.InstallUninstallType.both:
+                                    events |= MsiInterop.MsidbServiceControlEventDelete | MsiInterop.MsidbServiceControlEventUninstallDelete;
+                                    break;
+                            }
+                            break;
+                        case "Start":
+                            Wix.InstallUninstallType startValue = this.core.GetAttributeInstallUninstallValue(sourceLineNumbers, attrib);
+                            switch (startValue)
+                            {
+                                case Wix.InstallUninstallType.install:
+                                    events |= MsiInterop.MsidbServiceControlEventStart;
+                                    break;
+                                case Wix.InstallUninstallType.uninstall:
+                                    events |= MsiInterop.MsidbServiceControlEventUninstallStart;
+                                    break;
+                                case Wix.InstallUninstallType.both:
+                                    events |= MsiInterop.MsidbServiceControlEventStart | MsiInterop.MsidbServiceControlEventUninstallStart;
+                                    break;
+                            }
+                            break;
+                        case "Stop":
+                            Wix.InstallUninstallType stopValue = this.core.GetAttributeInstallUninstallValue(sourceLineNumbers, attrib);
+                            switch (stopValue)
+                            {
+                                case Wix.InstallUninstallType.install:
+                                    events |= MsiInterop.MsidbServiceControlEventStop;
+                                    break;
+                                case Wix.InstallUninstallType.uninstall:
+                                    events |= MsiInterop.MsidbServiceControlEventUninstallStop;
+                                    break;
+                                case Wix.InstallUninstallType.both:
+                                    events |= MsiInterop.MsidbServiceControlEventStop | MsiInterop.MsidbServiceControlEventUninstallStop;
+                                    break;
+                            }
+                            break;
+                        case "Wait":
+                            wait = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                id = this.core.CreateIdentifierFromFilename(name);
+            }
+
+            if (null == name)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Name"));
+            }
+
+            // get the ServiceControl arguments
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "ServiceArgument":
+                            if (null != arguments)
+                            {
+                                arguments = String.Concat(arguments, "[~]");
+                            }
+                            arguments = String.Concat(arguments, this.core.GetTrimmedInnerText(child));
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "ServiceControl", id);
+                row[1] = name;
+                row[2] = events;
+                row[3] = arguments;
+                if (YesNoType.NotSet != wait)
+                {
+                    row[4] = YesNoType.Yes == wait ? 1 : 0;
+                }
+                row[5] = componentId;
+            }
+        }
+
+        /// <summary>
+        /// Parses a service dependency element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <returns>Parsed sevice dependency name.</returns>
+        private string ParseServiceDependencyElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string dependency = null;
+            bool group = false;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            dependency = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Group":
+                            group = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == dependency)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            return group ? String.Concat("+", dependency) : dependency;
+        }
+
+        /// <summary>
+        /// Parses a service install element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="componentId">Identifier of parent component.</param>
+        private void ParseServiceInstallElement(XElement node, string componentId, bool win64Component)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            string account = null;
+            string arguments = null;
+            string dependencies = null;
+            string description = null;
+            string displayName = null;
+            bool eraseDescription = false;
+            int errorbits = 0;
+            string loadOrderGroup = null;
+            string name = null;
+            string password = null;
+            int startType = 0;
+            int typebits = 0;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Account":
+                            account = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Arguments":
+                            arguments = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Description":
+                            description = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "DisplayName":
+                            displayName = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "EraseDescription":
+                            eraseDescription = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ErrorControl":
+                            string errorControlValue = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (0 < errorControlValue.Length)
+                            {
+                                Wix.ServiceInstall.ErrorControlType errorControlType = Wix.ServiceInstall.ParseErrorControlType(errorControlValue);
+                                switch (errorControlType)
+                                {
+                                    case Wix.ServiceInstall.ErrorControlType.ignore:
+                                        errorbits |= MsiInterop.MsidbServiceInstallErrorIgnore;
+                                        break;
+                                    case Wix.ServiceInstall.ErrorControlType.normal:
+                                        errorbits |= MsiInterop.MsidbServiceInstallErrorNormal;
+                                        break;
+                                    case Wix.ServiceInstall.ErrorControlType.critical:
+                                        errorbits |= MsiInterop.MsidbServiceInstallErrorCritical;
+                                        break;
+                                    default:
+                                        this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, errorControlValue, "ignore", "normal", "critical"));
+                                        break;
+                                }
+                            }
+                            break;
+                        case "Interactive":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                typebits |= MsiInterop.MsidbServiceInstallInteractive;
+                            }
+                            break;
+                        case "LoadOrderGroup":
+                            loadOrderGroup = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Name":
+                            name = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Password":
+                            password = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Start":
+                            string startValue = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (0 < startValue.Length)
+                            {
+                                Wix.ServiceInstall.StartType start = Wix.ServiceInstall.ParseStartType(startValue);
+                                switch (start)
+                                {
+                                    case Wix.ServiceInstall.StartType.auto:
+                                        startType = MsiInterop.MsidbServiceInstallAutoStart;
+                                        break;
+                                    case Wix.ServiceInstall.StartType.demand:
+                                        startType = MsiInterop.MsidbServiceInstallDemandStart;
+                                        break;
+                                    case Wix.ServiceInstall.StartType.disabled:
+                                        startType = MsiInterop.MsidbServiceInstallDisabled;
+                                        break;
+                                    case Wix.ServiceInstall.StartType.boot:
+                                    case Wix.ServiceInstall.StartType.system:
+                                        this.core.OnMessage(WixErrors.ValueNotSupported(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, startValue));
+                                        break;
+                                    default:
+                                        this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, startValue, "auto", "demand", "disabled"));
+                                        break;
+                                }
+                            }
+                            break;
+                        case "Type":
+                            string typeValue = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (0 < typeValue.Length)
+                            {
+                                Wix.ServiceInstall.TypeType typeType = Wix.ServiceInstall.ParseTypeType(typeValue);
+                                switch (typeType)
+                                {
+                                    case Wix.ServiceInstall.TypeType.ownProcess:
+                                        typebits |= MsiInterop.MsidbServiceInstallOwnProcess;
+                                        break;
+                                    case Wix.ServiceInstall.TypeType.shareProcess:
+                                        typebits |= MsiInterop.MsidbServiceInstallShareProcess;
+                                        break;
+                                    case Wix.ServiceInstall.TypeType.kernelDriver:
+                                    case Wix.ServiceInstall.TypeType.systemDriver:
+                                        this.core.OnMessage(WixErrors.ValueNotSupported(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, typeValue));
+                                        break;
+                                    default:
+                                        this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, node.Name.LocalName, typeValue, "ownProcess", "shareProcess"));
+                                        break;
+                                }
+                            }
+                            break;
+                        case "Vital":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                errorbits |= MsiInterop.MsidbServiceInstallErrorControlVital;
+                            }
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (String.IsNullOrEmpty(name))
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Name"));
+            }
+            else if (null == id)
+            {
+                id = this.core.CreateIdentifierFromFilename(name);
+            }
+
+            if (0 == startType)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Start"));
+            }
+
+            if (eraseDescription)
+            {
+                description = "[~]";
+            }
+
+            // get the ServiceInstall dependencies and config
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "PermissionEx":
+                            this.ParsePermissionExElement(child, id.Id, "ServiceInstall");
+                            break;
+                        case "ServiceConfig":
+                            this.ParseServiceConfigElement(child, componentId, name);
+                            break;
+                        case "ServiceConfigFailureActions":
+                            this.ParseServiceConfigFailureActionsElement(child, componentId, name);
+                            break;
+                        case "ServiceDependency":
+                            dependencies = String.Concat(dependencies, this.ParseServiceDependencyElement(child), "[~]");
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    Dictionary<string, string> context = new Dictionary<string, string>() { { "ServiceInstallId", id.Id }, { "ServiceInstallName", name }, { "ServiceInstallComponentId", componentId }, { "Win64", win64Component.ToString() } };
+                    this.core.ParseExtensionElement(node, child, context);
+                }
+            }
+
+            if (null != dependencies)
+            {
+                dependencies = String.Concat(dependencies, "[~]");
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "ServiceInstall", id);
+                row[1] = name;
+                row[2] = displayName;
+                row[3] = typebits;
+                row[4] = startType;
+                row[5] = errorbits;
+                row[6] = loadOrderGroup;
+                row[7] = dependencies;
+                row[8] = account;
+                row[9] = password;
+                row[10] = arguments;
+                row[11] = componentId;
+                row[12] = description;
+            }
+        }
+
+        /// <summary>
+        /// Parses a SetDirectory element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        private void ParseSetDirectoryElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string actionName = null;
+            string id = null;
+            string condition = null;
+            string[] sequences = new string[] { "InstallUISequence", "InstallExecuteSequence" }; // default to "both"
+            int extraBits = 0;
+            string value = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Action":
+                            actionName = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Id":
+                            id = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.core.CreateSimpleReference(sourceLineNumbers, "Directory", id);
+                            break;
+                        case "Sequence":
+                            string sequenceValue = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (0 < sequenceValue.Length)
+                            {
+                                Wix.SequenceType sequenceType = Wix.Enums.ParseSequenceType(sequenceValue);
+                                switch (sequenceType)
+                                {
+                                    case Wix.SequenceType.execute:
+                                        sequences = new string[] { "InstallExecuteSequence" };
+                                        break;
+                                    case Wix.SequenceType.ui:
+                                        sequences = new string[] { "InstallUISequence" };
+                                        break;
+                                    case Wix.SequenceType.first:
+                                        extraBits = MsiInterop.MsidbCustomActionTypeFirstSequence;
+                                        // default puts it in both sequence which is what we want
+                                        break;
+                                    case Wix.SequenceType.both:
+                                        // default so no work necessary.
+                                        break;
+                                    default:
+                                        this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, sequenceValue, "execute", "ui", "both"));
+                                        break;
+                                }
+                            }
+                            break;
+                        case "Value":
+                            value = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            condition = this.core.GetConditionInnerText(node);
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+            else if (String.IsNullOrEmpty(actionName))
+            {
+                actionName = String.Concat("Set", id);
+            }
+
+            if (null == value)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Value"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            // add the row and any references needed
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "CustomAction");
+                row[0] = actionName;
+                row[1] = MsiInterop.MsidbCustomActionTypeProperty | MsiInterop.MsidbCustomActionTypeTextData | extraBits;
+                row[2] = id;
+                row[3] = value;
+
+                foreach (string sequence in sequences)
+                {
+                    Row sequenceRow = this.core.CreateRow(sourceLineNumbers, "WixAction");
+                    sequenceRow[0] = sequence;
+                    sequenceRow[1] = actionName;
+                    sequenceRow[2] = condition;
+                    // no explicit sequence
+                    // no before action
+                    sequenceRow[5] = "CostInitialize";
+                    sequenceRow[6] = 0; // not overridable
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses a SetProperty element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        private void ParseSetPropertyElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string actionName = null;
+            string id = null;
+            string afterAction = null;
+            string beforeAction = null;
+            string condition = null;
+            string[] sequences = new string[] { "InstallUISequence", "InstallExecuteSequence" }; // default to "both"
+            int extraBits = 0;
+            string value = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Action":
+                            actionName = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Id":
+                            id = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        case "After":
+                            afterAction = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Before":
+                            beforeAction = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Sequence":
+                            string sequenceValue = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (0 < sequenceValue.Length)
+                            {
+                                Wix.SequenceType sequenceType = Wix.Enums.ParseSequenceType(sequenceValue);
+                                switch (sequenceType)
+                                {
+                                    case Wix.SequenceType.execute:
+                                        sequences = new string[] { "InstallExecuteSequence" };
+                                        break;
+                                    case Wix.SequenceType.ui:
+                                        sequences = new string[] { "InstallUISequence" };
+                                        break;
+                                    case Wix.SequenceType.first:
+                                        extraBits = MsiInterop.MsidbCustomActionTypeFirstSequence;
+                                        // default puts it in both sequence which is what we want
+                                        break;
+                                    case Wix.SequenceType.both:
+                                        // default so no work necessary.
+                                        break;
+                                    default:
+                                        this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, sequenceValue, "execute", "ui", "both"));
+                                        break;
+                                }
+                            }
+                            break;
+                        case "Value":
+                            value = this.core.GetAttributeValue(sourceLineNumbers, attrib, EmptyRule.CanBeEmpty);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            condition = this.core.GetConditionInnerText(node);
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+            else if (String.IsNullOrEmpty(actionName))
+            {
+                actionName = String.Concat("Set", id);
+            }
+
+            if (null == value)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Value"));
+            }
+
+            if (null != beforeAction && null != afterAction)
+            {
+                this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "After", "Before"));
+            }
+            else if (null == beforeAction && null == afterAction)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttributesWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "After", "Before", "Id"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            // add the row and any references needed
+            if (!this.core.EncounteredError)
+            {
+                // action that is scheduled to occur before/after itself
+                if (beforeAction == actionName)
+                {
+                    this.core.OnMessage(WixErrors.ActionScheduledRelativeToItself(sourceLineNumbers, node.Name.LocalName, "Before", beforeAction));
+                }
+                else if (afterAction == actionName)
+                {
+                    this.core.OnMessage(WixErrors.ActionScheduledRelativeToItself(sourceLineNumbers, node.Name.LocalName, "After", afterAction));
+                }
+
+                Row row = this.core.CreateRow(sourceLineNumbers, "CustomAction");
+                row[0] = actionName;
+                row[1] = MsiInterop.MsidbCustomActionTypeProperty | MsiInterop.MsidbCustomActionTypeTextData | extraBits;
+                row[2] = id;
+                row[3] = value;
+
+                foreach (string sequence in sequences)
+                {
+                    Row sequenceRow = this.core.CreateRow(sourceLineNumbers, "WixAction");
+                    sequenceRow[0] = sequence;
+                    sequenceRow[1] = actionName;
+                    sequenceRow[2] = condition;
+                    // no explicit sequence
+                    sequenceRow[4] = beforeAction;
+                    sequenceRow[5] = afterAction;
+                    sequenceRow[6] = 0; // not overridable
+
+                    if (null != beforeAction)
+                    {
+                        if (WindowsInstallerStandard.IsStandardAction(beforeAction))
+                        {
+                            this.core.CreateSimpleReference(sourceLineNumbers, "WixAction", sequence, beforeAction);
+                        }
+                        else
+                        {
+                            this.core.CreateSimpleReference(sourceLineNumbers, "CustomAction", beforeAction);
+                        }
+                    }
+
+                    if (null != afterAction)
+                    {
+                        if (WindowsInstallerStandard.IsStandardAction(afterAction))
+                        {
+                            this.core.CreateSimpleReference(sourceLineNumbers, "WixAction", sequence, afterAction);
+                        }
+                        else
+                        {
+                            this.core.CreateSimpleReference(sourceLineNumbers, "CustomAction", afterAction);
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses a SFP catalog element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="parentSFPCatalog">Parent SFPCatalog.</param>
+        private void ParseSFPFileElement(XElement node, string parentSFPCatalog)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string id = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "FileSFPCatalog");
+                row[0] = id;
+                row[1] = parentSFPCatalog;
+            }
+        }
+
+        /// <summary>
+        /// Parses a SFP catalog element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="parentSFPCatalog">Parent SFPCatalog.</param>
+        private void ParseSFPCatalogElement(XElement node, ref string parentSFPCatalog)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string parentName = null;
+            string dependency = null;
+            string name = null;
+            string sourceFile = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Dependency":
+                            dependency = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Name":
+                            name = this.core.GetAttributeShortFilename(sourceLineNumbers, attrib, false);
+                            parentSFPCatalog = name;
+                            break;
+                        case "SourceFile":
+                            sourceFile = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == name)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Name"));
+            }
+
+            if (null == sourceFile)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "SourceFile"));
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "SFPCatalog":
+                            this.ParseSFPCatalogElement(child, ref parentName);
+                            if (null != dependency && parentName == dependency)
+                            {
+                                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Dependency"));
+                            }
+                            dependency = parentName;
+                            break;
+                        case "SFPFile":
+                            this.ParseSFPFileElement(child, name);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (null == dependency)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Dependency"));
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "SFPCatalog");
+                row[0] = name;
+                row[1] = sourceFile;
+                row[2] = dependency;
+            }
+        }
+
+        /// <summary>
+        /// Parses a shortcut element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="componentId">Identifer for parent component.</param>
+        /// <param name="parentElementLocalName">Local name of parent element.</param>
+        /// <param name="defaultTarget">Default identifier of parent (which is usually the target).</param>
+        /// <param name="parentKeyPath">Flag to indicate whether the parent element is the keypath of a component or not (will only be true for file parent elements).</param>
+        private void ParseShortcutElement(XElement node, string componentId, string parentElementLocalName, string defaultTarget, YesNoType parentKeyPath)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            bool advertise = false;
+            string arguments = null;
+            string description = null;
+            string descriptionResourceDll = null;
+            int descriptionResourceId = CompilerConstants.IntegerNotSet;
+            string directory = null;
+            string displayResourceDll = null;
+            int displayResourceId = CompilerConstants.IntegerNotSet;
+            int hotkey = CompilerConstants.IntegerNotSet;
+            string icon = null;
+            int iconIndex = CompilerConstants.IntegerNotSet;
+            string name = null;
+            string shortName = null;
+            int show = CompilerConstants.IntegerNotSet;
+            string target = null;
+            string workingDirectory = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Advertise":
+                            advertise = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Arguments":
+                            arguments = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Description":
+                            description = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "DescriptionResourceDll":
+                            descriptionResourceDll = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "DescriptionResourceId":
+                            descriptionResourceId = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, short.MaxValue);
+                            break;
+                        case "Directory":
+                            directory = this.core.CreateDirectoryReferenceFromInlineSyntax(sourceLineNumbers, attrib, null);
+                            break;
+                        case "DisplayResourceDll":
+                            displayResourceDll = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "DisplayResourceId":
+                            displayResourceId = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, short.MaxValue);
+                            break;
+                        case "Hotkey":
+                            hotkey = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, short.MaxValue);
+                            break;
+                        case "Icon":
+                            icon = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.core.CreateSimpleReference(sourceLineNumbers, "Icon", icon);
+                            break;
+                        case "IconIndex":
+                            iconIndex = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, short.MinValue + 1, short.MaxValue);
+                            break;
+                        case "Name":
+                            name = this.core.GetAttributeLongFilename(sourceLineNumbers, attrib, false);
+                            break;
+                        case "ShortName":
+                            shortName = this.core.GetAttributeShortFilename(sourceLineNumbers, attrib, false);
+                            break;
+                        case "Show":
+                            string showValue = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (showValue.Length == 0)
+                            {
+                                show = CompilerConstants.IllegalInteger;
+                            }
+                            else
+                            {
+                                Wix.Shortcut.ShowType showType = Wix.Shortcut.ParseShowType(showValue);
+                                switch (showType)
+                                {
+                                    case Wix.Shortcut.ShowType.normal:
+                                        show = 1;
+                                        break;
+                                    case Wix.Shortcut.ShowType.maximized:
+                                        show = 3;
+                                        break;
+                                    case Wix.Shortcut.ShowType.minimized:
+                                        show = 7;
+                                        break;
+                                    default:
+                                        this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, "Show", showValue, "normal", "maximized", "minimized"));
+                                        show = CompilerConstants.IllegalInteger;
+                                        break;
+                                }
+                            }
+                            break;
+                        case "Target":
+                            target = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "WorkingDirectory":
+                            workingDirectory = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (advertise && null != target)
+            {
+                this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "Target", "Advertise", "yes"));
+            }
+
+            if (null == directory)
+            {
+                if ("Component" == parentElementLocalName)
+                {
+                    directory = defaultTarget;
+                }
+                else
+                {
+                    this.core.OnMessage(WixErrors.ExpectedAttributeWhenElementNotUnderElement(sourceLineNumbers, node.Name.LocalName, "Directory", "Component"));
+                }
+            }
+
+            if (null != descriptionResourceDll)
+            {
+                if (CompilerConstants.IntegerNotSet == descriptionResourceId)
+                {
+                    this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "DescriptionResourceDll", "DescriptionResourceId"));
+                }
+            }
+            else
+            {
+                if (CompilerConstants.IntegerNotSet != descriptionResourceId)
+                {
+                    this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "DescriptionResourceId", "DescriptionResourceDll"));
+                }
+            }
+
+            if (null != displayResourceDll)
+            {
+                if (CompilerConstants.IntegerNotSet == displayResourceId)
+                {
+                    this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "DisplayResourceDll", "DisplayResourceId"));
+                }
+            }
+            else
+            {
+                if (CompilerConstants.IntegerNotSet != displayResourceId)
+                {
+                    this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "DisplayResourceId", "DisplayResourceDll"));
+                }
+            }
+
+            if (null == name)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Name"));
+            }
+            else if (0 < name.Length)
+            {
+                if (this.core.IsValidShortFilename(name, false))
+                {
+                    if (null == shortName)
+                    {
+                        shortName = name;
+                        name = null;
+                    }
+                    else
+                    {
+                        this.core.OnMessage(WixErrors.IllegalAttributeValueWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "Name", name, "ShortName"));
+                    }
+                }
+                else if (null == shortName) // generate a short file name.
+                {
+                    shortName = this.core.CreateShortName(name, true, false, node.Name.LocalName, componentId, directory);
+                }
+            }
+
+            if ("Component" != parentElementLocalName && null != target)
+            {
+                this.core.OnMessage(WixErrors.IllegalAttributeWhenNested(sourceLineNumbers, node.Name.LocalName, "Target", parentElementLocalName));
+            }
+
+            if (null == id)
+            {
+                id = this.core.CreateIdentifier("sct", directory, LowercaseOrNull(name) ?? LowercaseOrNull(shortName));
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "Icon":
+                            icon = this.ParseIconElement(child);
+                            break;
+                        case "ShortcutProperty":
+                            this.ParseShortcutPropertyElement(child, id.Id);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "Shortcut", id);
+                row[1] = directory;
+                row[2] = GetMsiFilenameValue(shortName, name);
+                row[3] = componentId;
+                if (advertise)
+                {
+                    if (YesNoType.Yes != parentKeyPath && "Component" != parentElementLocalName)
+                    {
+                        this.core.OnMessage(WixWarnings.UnclearShortcut(sourceLineNumbers, id.Id, componentId, defaultTarget));
+                    }
+                    row[4] = Guid.Empty.ToString("B");
+                }
+                else if (null != target)
+                {
+                    row[4] = target;
+                }
+                else if ("Component" == parentElementLocalName || "CreateFolder" == parentElementLocalName)
+                {
+                    row[4] = String.Format(CultureInfo.InvariantCulture, "[{0}]", defaultTarget);
+                }
+                else if ("File" == parentElementLocalName)
+                {
+                    row[4] = String.Format(CultureInfo.InvariantCulture, "[#{0}]", defaultTarget);
+                }
+                row[5] = arguments;
+                row[6] = description;
+                if (CompilerConstants.IntegerNotSet != hotkey)
+                {
+                    row[7] = hotkey;
+                }
+                row[8] = icon;
+                if (CompilerConstants.IntegerNotSet != iconIndex)
+                {
+                    row[9] = iconIndex;
+                }
+
+                if (CompilerConstants.IntegerNotSet != show)
+                {
+                    row[10] = show;
+                }
+                row[11] = workingDirectory;
+                row[12] = displayResourceDll;
+                if (CompilerConstants.IntegerNotSet != displayResourceId)
+                {
+                    row[13] = displayResourceId;
+                }
+                row[14] = descriptionResourceDll;
+                if (CompilerConstants.IntegerNotSet != descriptionResourceId)
+                {
+                    row[15] = descriptionResourceId;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses a shortcut property element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        private void ParseShortcutPropertyElement(XElement node, string shortcutId)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            string key = null;
+            string value = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Key":
+                            key = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Value":
+                            value = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (String.IsNullOrEmpty(key))
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Key"));
+            }
+            else if (null == id)
+            {
+                id = this.core.CreateIdentifier("scp", shortcutId, key.ToUpperInvariant());
+            }
+
+            string innerText = this.core.GetTrimmedInnerText(node);
+            if (!String.IsNullOrEmpty(innerText))
+            {
+                if (String.IsNullOrEmpty(value))
+                {
+                    value = innerText;
+                }
+                else // cannot specify both the value attribute and inner text
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeWithInnerText(sourceLineNumbers, node.Name.LocalName, "Value"));
+                }
+            }
+
+            if (String.IsNullOrEmpty(value))
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Value"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "MsiShortcutProperty", id);
+                row[1] = shortcutId;
+                row[2] = key;
+                row[3] = value;
+            }
+        }
+
+        /// <summary>
+        /// Parses a typelib element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="componentId">Identifier of parent component.</param>
+        /// <param name="fileServer">Identifier of file that acts as typelib server.</param>
+        /// <param name="win64Component">true if the component is 64-bit.</param>
+        private void ParseTypeLibElement(XElement node, string componentId, string fileServer, bool win64Component)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string id = null;
+            YesNoType advertise = YesNoType.NotSet;
+            int cost = CompilerConstants.IntegerNotSet;
+            string description = null;
+            int flags = 0;
+            string helpDirectory = null;
+            int language = CompilerConstants.IntegerNotSet;
+            int majorVersion = CompilerConstants.IntegerNotSet;
+            int minorVersion = CompilerConstants.IntegerNotSet;
+            long resourceId = CompilerConstants.LongNotSet;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeGuidValue(sourceLineNumbers, attrib, false);
+                            break;
+                        case "Advertise":
+                            advertise = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Control":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                flags |= 2;
+                            }
+                            break;
+                        case "Cost":
+                            cost = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, int.MaxValue);
+                            break;
+                        case "Description":
+                            description = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "HasDiskImage":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                flags |= 8;
+                            }
+                            break;
+                        case "HelpDirectory":
+                            helpDirectory = this.core.CreateDirectoryReferenceFromInlineSyntax(sourceLineNumbers, attrib, null);
+                            break;
+                        case "Hidden":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                flags |= 4;
+                            }
+                            break;
+                        case "Language":
+                            language = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, short.MaxValue);
+                            break;
+                        case "MajorVersion":
+                            majorVersion = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, ushort.MaxValue);
+                            break;
+                        case "MinorVersion":
+                            minorVersion = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, byte.MaxValue);
+                            break;
+                        case "ResourceId":
+                            resourceId = this.core.GetAttributeLongValue(sourceLineNumbers, attrib, int.MinValue, int.MaxValue);
+                            break;
+                        case "Restricted":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                flags |= 1;
+                            }
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            if (CompilerConstants.IntegerNotSet == language)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Language"));
+                language = CompilerConstants.IllegalInteger;
+            }
+
+            // build up the typelib version string for the registry if the major or minor version was specified
+            string registryVersion = null;
+            if (CompilerConstants.IntegerNotSet != majorVersion || CompilerConstants.IntegerNotSet != minorVersion)
+            {
+                if (CompilerConstants.IntegerNotSet != majorVersion)
+                {
+                    registryVersion = majorVersion.ToString("x", CultureInfo.InvariantCulture.NumberFormat);
+                }
+                else
+                {
+                    registryVersion = "0";
+                }
+
+                if (CompilerConstants.IntegerNotSet != minorVersion)
+                {
+                    registryVersion = String.Concat(registryVersion, ".", minorVersion.ToString("x", CultureInfo.InvariantCulture.NumberFormat));
+                }
+                else
+                {
+                    registryVersion = String.Concat(registryVersion, ".0");
+                }
+            }
+
+            // if the advertise state has not been set, default to non-advertised
+            if (YesNoType.NotSet == advertise)
+            {
+                advertise = YesNoType.No;
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "AppId":
+                            this.ParseAppIdElement(child, componentId, YesNoType.NotSet, fileServer, id, registryVersion);
+                            break;
+                        case "Class":
+                            this.ParseClassElement(child, componentId, YesNoType.NotSet, fileServer, id, registryVersion, null);
+                            break;
+                        case "Interface":
+                            this.ParseInterfaceElement(child, componentId, null, null, id, registryVersion);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+
+            if (YesNoType.Yes == advertise)
+            {
+                if (CompilerConstants.LongNotSet != resourceId)
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeWhenAdvertised(sourceLineNumbers, node.Name.LocalName, "ResourceId"));
+                }
+
+                if (0 != flags)
+                {
+                    if (0x1 == (flags & 0x1))
+                    {
+                        this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "Restricted", "Advertise", "yes"));
+                    }
+
+                    if (0x2 == (flags & 0x2))
+                    {
+                        this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "Control", "Advertise", "yes"));
+                    }
+
+                    if (0x4 == (flags & 0x4))
+                    {
+                        this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "Hidden", "Advertise", "yes"));
+                    }
+
+                    if (0x8 == (flags & 0x8))
+                    {
+                        this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "HasDiskImage", "Advertise", "yes"));
+                    }
+                }
+
+                if (!this.core.EncounteredError)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "TypeLib");
+                    row[0] = id;
+                    row[1] = language;
+                    row[2] = componentId;
+                    if (CompilerConstants.IntegerNotSet != majorVersion || CompilerConstants.IntegerNotSet != minorVersion)
+                    {
+                        row[3] = (CompilerConstants.IntegerNotSet != majorVersion ? majorVersion * 256 : 0) + (CompilerConstants.IntegerNotSet != minorVersion ? minorVersion : 0);
+                    }
+                    row[4] = description;
+                    row[5] = helpDirectory;
+                    row[6] = Guid.Empty.ToString("B");
+                    if (CompilerConstants.IntegerNotSet != cost)
+                    {
+                        row[7] = cost;
+                    }
+                }
+            }
+            else if (YesNoType.No == advertise)
+            {
+                if (CompilerConstants.IntegerNotSet != cost && CompilerConstants.IllegalInteger != cost)
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "Cost", "Advertise", "no"));
+                }
+
+                if (null == fileServer)
+                {
+                    this.core.OnMessage(WixErrors.MissingTypeLibFile(sourceLineNumbers, node.Name.LocalName, "File"));
+                }
+
+                if (null == registryVersion)
+                {
+                    this.core.OnMessage(WixErrors.ExpectedAttributesWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "MajorVersion", "MinorVersion", "Advertise", "no"));
+                }
+
+                // HKCR\TypeLib\[ID]\[MajorVersion].[MinorVersion], (Default) = [Description]
+                this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Format(CultureInfo.InvariantCulture, @"TypeLib\{0}\{1}", id, registryVersion), null, description, componentId);
+
+                // HKCR\TypeLib\[ID]\[MajorVersion].[MinorVersion]\[Language]\[win16|win32|win64], (Default) = [TypeLibPath]\[ResourceId]
+                string path = String.Concat("[#", fileServer, "]");
+                if (CompilerConstants.LongNotSet != resourceId)
+                {
+                    path = String.Concat(path, Path.DirectorySeparatorChar, resourceId.ToString(CultureInfo.InvariantCulture.NumberFormat));
+                }
+                this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Format(CultureInfo.InvariantCulture, @"TypeLib\{0}\{1}\{2}\{3}", id, registryVersion, language, (win64Component ? "win64" : "win32")), null, path, componentId);
+
+                // HKCR\TypeLib\[ID]\[MajorVersion].[MinorVersion]\FLAGS, (Default) = [TypeLibFlags]
+                this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Format(CultureInfo.InvariantCulture, @"TypeLib\{0}\{1}\FLAGS", id, registryVersion), null, flags.ToString(CultureInfo.InvariantCulture.NumberFormat), componentId);
+
+                if (null != helpDirectory)
+                {
+                    // HKCR\TypeLib\[ID]\[MajorVersion].[MinorVersion]\HELPDIR, (Default) = [HelpDirectory]
+                    this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Format(CultureInfo.InvariantCulture, @"TypeLib\{0}\{1}\HELPDIR", id, registryVersion), null, String.Concat("[", helpDirectory, "]"), componentId);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses an EmbeddedChaniner element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        private void ParseEmbeddedChainerElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            string commandLine = null;
+            string condition = null;
+            string source = null;
+            int type = 0;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "BinarySource":
+                            if (null != source)
+                            {
+                                this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttributes(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, "FileSource", "PropertySource"));
+                            }
+                            source = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            type = MsiInterop.MsidbCustomActionTypeExe + MsiInterop.MsidbCustomActionTypeBinaryData;
+                            this.core.CreateSimpleReference(sourceLineNumbers, "Binary", source); // add a reference to the appropriate Binary
+                            break;
+                        case "CommandLine":
+                            commandLine = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "FileSource":
+                            if (null != source)
+                            {
+                                this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttributes(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, "BinarySource", "PropertySource"));
+                            }
+                            source = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            type = MsiInterop.MsidbCustomActionTypeExe + MsiInterop.MsidbCustomActionTypeSourceFile;
+                            this.core.CreateSimpleReference(sourceLineNumbers, "File", source); // add a reference to the appropriate File
+                            break;
+                        case "PropertySource":
+                            if (null != source)
+                            {
+                                this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttributes(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, "BinarySource", "FileSource"));
+                            }
+                            source = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            type = MsiInterop.MsidbCustomActionTypeExe + MsiInterop.MsidbCustomActionTypeProperty;
+                            // cannot add a reference to a Property because it may be created at runtime.
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            // Get the condition from the inner text of the element.
+            condition = this.core.GetConditionInnerText(node);
+
+            if (null == id)
+            {
+                id = this.core.CreateIdentifier("mec", source, type.ToString());
+            }
+
+            if (null == source)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttributes(sourceLineNumbers, node.Name.LocalName, "BinarySource", "FileSource", "PropertySource"));
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "MsiEmbeddedChainer", id);
+                row[1] = condition;
+                row[2] = commandLine;
+                row[3] = source;
+                row[4] = type;
+            }
+        }
+
+        /// <summary>
+        /// Parses UI elements.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        private void ParseUIElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            int embeddedUICount = 0;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "BillboardAction":
+                            this.ParseBillboardActionElement(child);
+                            break;
+                        case "ComboBox":
+                            this.ParseControlGroupElement(child, this.tableDefinitions["ComboBox"], "ListItem");
+                            break;
+                        case "Dialog":
+                            this.ParseDialogElement(child);
+                            break;
+                        case "DialogRef":
+                            this.ParseSimpleRefElement(child, "Dialog");
+                            break;
+                        case "EmbeddedUI":
+                            if (0 < embeddedUICount) // there can be only one embedded UI
+                            {
+                                SourceLineNumber childSourceLineNumbers = Preprocessor.GetSourceLineNumbers(child);
+                                this.core.OnMessage(WixErrors.TooManyChildren(childSourceLineNumbers, node.Name.LocalName, child.Name.LocalName));
+                            }
+                            this.ParseEmbeddedUIElement(child);
+                            ++embeddedUICount;
+                            break;
+                        case "Error":
+                            this.ParseErrorElement(child);
+                            break;
+                        case "ListBox":
+                            this.ParseControlGroupElement(child, this.tableDefinitions["ListBox"], "ListItem");
+                            break;
+                        case "ListView":
+                            this.ParseControlGroupElement(child, this.tableDefinitions["ListView"], "ListItem");
+                            break;
+                        case "ProgressText":
+                            this.ParseActionTextElement(child);
+                            break;
+                        case "Publish":
+                            int order = 0;
+                            this.ParsePublishElement(child, null, null, ref order);
+                            break;
+                        case "RadioButtonGroup":
+                            RadioButtonType radioButtonType = this.ParseRadioButtonGroupElement(child, null, RadioButtonType.NotSet);
+                            if (RadioButtonType.Bitmap == radioButtonType || RadioButtonType.Icon == radioButtonType)
+                            {
+                                SourceLineNumber childSourceLineNumbers = Preprocessor.GetSourceLineNumbers(child);
+                                this.core.OnMessage(WixErrors.RadioButtonBitmapAndIconDisallowed(childSourceLineNumbers));
+                            }
+                            break;
+                        case "TextStyle":
+                            this.ParseTextStyleElement(child);
+                            break;
+                        case "UIText":
+                            this.ParseUITextElement(child);
+                            break;
+
+                        // the following are available indentically under the UI and Product elements for document organization use only
+                        case "AdminUISequence":
+                        case "InstallUISequence":
+                            this.ParseSequenceElement(child, child.Name.LocalName);
+                            break;
+                        case "Binary":
+                            this.ParseBinaryElement(child);
+                            break;
+                        case "Property":
+                            this.ParsePropertyElement(child);
+                            break;
+                        case "PropertyRef":
+                            this.ParseSimpleRefElement(child, "Property");
+                            break;
+                        case "UIRef":
+                            this.ParseSimpleRefElement(child, "WixUI");
+                            break;
+
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (null != id && !this.core.EncounteredError)
+            {
+                this.core.CreateRow(sourceLineNumbers, "WixUI", id);
+            }
+        }
+
+        /// <summary>
+        /// Parses a list item element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="table">Table to add row to.</param>
+        /// <param name="property">Identifier of property referred to by list item.</param>
+        /// <param name="order">Relative order of list items.</param>
+        private void ParseListItemElement(XElement node, TableDefinition table, string property, ref int order)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string icon = null;
+            string text = null;
+            string value = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Icon":
+                            if ("ListView" == table.Name)
+                            {
+                                icon = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                                this.core.CreateSimpleReference(sourceLineNumbers, "Binary", icon);
+                            }
+                            else
+                            {
+                                this.core.OnMessage(WixErrors.IllegalAttributeExceptOnElement(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, "ListView"));
+                            }
+                            break;
+                        case "Text":
+                            text = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Value":
+                            value = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == value)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Value"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, table.Name);
+                row[0] = property;
+                row[1] = ++order;
+                row[2] = value;
+                row[3] = text;
+                if (null != icon)
+                {
+                    row[4] = icon;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses a radio button element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="property">Identifier of property referred to by radio button.</param>
+        /// <param name="order">Relative order of radio buttons.</param>
+        /// <returns>Type of this radio button.</returns>
+        private RadioButtonType ParseRadioButtonElement(XElement node, string property, ref int order)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            RadioButtonType type = RadioButtonType.NotSet;
+            string value = null;
+            string x = null;
+            string y = null;
+            string width = null;
+            string height = null;
+            string text = null;
+            string tooltip = null;
+            string help = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Bitmap":
+                            if (RadioButtonType.NotSet != type)
+                            {
+                                this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttributes(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, "Icon", "Text"));
+                            }
+                            text = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.core.CreateSimpleReference(sourceLineNumbers, "Binary", text);
+                            type = RadioButtonType.Bitmap;
+                            break;
+                        case "Height":
+                            height = this.core.GetAttributeLocalizableIntegerValue(sourceLineNumbers, attrib, 0, short.MaxValue);
+                            break;
+                        case "Help":
+                            help = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Icon":
+                            if (RadioButtonType.NotSet != type)
+                            {
+                                this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttributes(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, "Bitmap", "Text"));
+                            }
+                            text = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.core.CreateSimpleReference(sourceLineNumbers, "Binary", text);
+                            type = RadioButtonType.Icon;
+                            break;
+                        case "Text":
+                            if (RadioButtonType.NotSet != type)
+                            {
+                                this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, "Bitmap", "Icon"));
+                            }
+                            text = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            type = RadioButtonType.Text;
+                            break;
+                        case "ToolTip":
+                            tooltip = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Value":
+                            value = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Width":
+                            width = this.core.GetAttributeLocalizableIntegerValue(sourceLineNumbers, attrib, 0, short.MaxValue);
+                            break;
+                        case "X":
+                            x = this.core.GetAttributeLocalizableIntegerValue(sourceLineNumbers, attrib, 0, short.MaxValue);
+                            break;
+                        case "Y":
+                            y = this.core.GetAttributeLocalizableIntegerValue(sourceLineNumbers, attrib, 0, short.MaxValue);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == value)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Value"));
+            }
+
+            if (null == x)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "X"));
+            }
+
+            if (null == y)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Y"));
+            }
+
+            if (null == width)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Width"));
+            }
+
+            if (null == height)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Height"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "RadioButton");
+                row[0] = property;
+                row[1] = ++order;
+                row[2] = value;
+                row[3] = x;
+                row[4] = y;
+                row[5] = width;
+                row[6] = height;
+                row[7] = text;
+                if (null != tooltip || null != help)
+                {
+                    row[8] = String.Concat(tooltip, "|", help);
+                }
+            }
+
+            return type;
+        }
+
+        /// <summary>
+        /// Parses a billboard element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        private void ParseBillboardActionElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string action = null;
+            int order = 0;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            action = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.core.CreateSimpleReference(sourceLineNumbers, "WixAction", "InstallExecuteSequence", action);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == action)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "Billboard":
+                            order = order + 1;
+                            this.ParseBillboardElement(child, action, order);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses a billboard element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="action">Action for the billboard.</param>
+        /// <param name="order">Order of the billboard.</param>
+        private void ParseBillboardElement(XElement node, string action, int order)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            string feature = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Feature":
+                            feature = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.core.CreateSimpleReference(sourceLineNumbers, "Feature", feature);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                id = this.core.CreateIdentifier("bil", action, order.ToString(), feature);
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "Control":
+                            // These are all thrown away.
+                            Row lastTabRow = null;
+                            string firstControl = null;
+                            string defaultControl = null;
+                            string cancelControl = null;
+
+                            this.ParseControlElement(child, id.Id, this.tableDefinitions["BBControl"], ref lastTabRow, ref firstControl, ref defaultControl, ref cancelControl, false);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "Billboard", id);
+                row[1] = feature;
+                row[2] = action;
+                row[3] = order;
+            }
+        }
+
+        /// <summary>
+        /// Parses a control group element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="table">Table referred to by control group.</param>
+        /// <param name="childTag">Expected child elements.</param>
+        private void ParseControlGroupElement(XElement node, TableDefinition table, string childTag)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            int order = 0;
+            string property = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Property":
+                            property = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == property)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Property"));
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    if (childTag != child.Name.LocalName)
+                    {
+                        this.core.UnexpectedElement(node, child);
+                    }
+
+                    switch (child.Name.LocalName)
+                    {
+                        case "ListItem":
+                            this.ParseListItemElement(child, table, property, ref order);
+                            break;
+                        case "Property":
+                            this.ParsePropertyElement(child);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+        }
+
+        /// <summary>
+        /// Parses a radio button control group element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="property">Property associated with this radio button group.</param>
+        /// <param name="groupType">Specifies the current type of radio buttons in the group.</param>
+        /// <returns>The current type of radio buttons in the group.</returns>
+        private RadioButtonType ParseRadioButtonGroupElement(XElement node, string property, RadioButtonType groupType)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            int order = 0;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Property":
+                            property = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.core.CreateSimpleReference(sourceLineNumbers, "Property", property);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == property)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Property"));
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "RadioButton":
+                            RadioButtonType type = this.ParseRadioButtonElement(child, property, ref order);
+                            if (RadioButtonType.NotSet == groupType)
+                            {
+                                groupType = type;
+                            }
+                            else if (groupType != type)
+                            {
+                                SourceLineNumber childSourceLineNumbers = Preprocessor.GetSourceLineNumbers(child);
+                                this.core.OnMessage(WixErrors.RadioButtonTypeInconsistent(childSourceLineNumbers));
+                            }
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+
+            return groupType;
+        }
+
+        /// <summary>
+        /// Parses an action text element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        private void ParseActionTextElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string action = null;
+            string template = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Action":
+                            action = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Template":
+                            template = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == action)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Action"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "ActionText");
+                row[0] = action;
+                row[1] = Common.GetInnerText(node);
+                row[2] = template;
+            }
+        }
+
+        /// <summary>
+        /// Parses an ui text element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        private void ParseUITextElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            string text = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            text = Common.GetInnerText(node);
+
+            if (null == id)
+            {
+                id = this.core.CreateIdentifier("txt", text);
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "UIText", id);
+                row[1] = text;
+            }
+        }
+
+        /// <summary>
+        /// Parses a text style element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        private void ParseTextStyleElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            int bits = 0;
+            int color = CompilerConstants.IntegerNotSet;
+            string faceName = null;
+            string size = "0";
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+
+                        // RGB Values
+                        case "Red":
+                            int redColor = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, byte.MaxValue);
+                            if (CompilerConstants.IllegalInteger != redColor)
+                            {
+                                if (CompilerConstants.IntegerNotSet == color)
+                                {
+                                    color = redColor;
+                                }
+                                else
+                                {
+                                    color += redColor;
+                                }
+                            }
+                            break;
+                        case "Green":
+                            int greenColor = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, byte.MaxValue);
+                            if (CompilerConstants.IllegalInteger != greenColor)
+                            {
+                                if (CompilerConstants.IntegerNotSet == color)
+                                {
+                                    color = greenColor * 256;
+                                }
+                                else
+                                {
+                                    color += greenColor * 256;
+                                }
+                            }
+                            break;
+                        case "Blue":
+                            int blueColor = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, byte.MaxValue);
+                            if (CompilerConstants.IllegalInteger != blueColor)
+                            {
+                                if (CompilerConstants.IntegerNotSet == color)
+                                {
+                                    color = blueColor * 65536;
+                                }
+                                else
+                                {
+                                    color += blueColor * 65536;
+                                }
+                            }
+                            break;
+
+                        // Style values
+                        case "Bold":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                bits |= MsiInterop.MsidbTextStyleStyleBitsBold;
+                            }
+                            break;
+                        case "Italic":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                bits |= MsiInterop.MsidbTextStyleStyleBitsItalic;
+                            }
+                            break;
+                        case "Strike":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                bits |= MsiInterop.MsidbTextStyleStyleBitsStrike;
+                            }
+                            break;
+                        case "Underline":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                bits |= MsiInterop.MsidbTextStyleStyleBitsUnderline;
+                            }
+                            break;
+
+                        // Font values
+                        case "FaceName":
+                            faceName = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Size":
+                            size = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.CreateIdentifier("txs", faceName, size.ToString(), color.ToString(), bits.ToString());
+            }
+
+            if (null == faceName)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "FaceName"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "TextStyle", id);
+                row[1] = faceName;
+                row[2] = size;
+                if (0 <= color)
+                {
+                    row[3] = color;
+                }
+
+                if (0 < bits)
+                {
+                    row[4] = bits;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses a dialog element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        private void ParseDialogElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            int bits = MsiInterop.MsidbDialogAttributesVisible | MsiInterop.MsidbDialogAttributesModal | MsiInterop.MsidbDialogAttributesMinimize;
+            int height = 0;
+            string title = null;
+            bool trackDiskSpace = false;
+            int width = 0;
+            int x = 50;
+            int y = 50;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Height":
+                            height = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, short.MaxValue);
+                            break;
+                        case "Title":
+                            title = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Width":
+                            width = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, short.MaxValue);
+                            break;
+                        case "X":
+                            x = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, 100);
+                            break;
+                        case "Y":
+                            y = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, 100);
+                            break;
+
+                        case "CustomPalette":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                bits ^= MsiInterop.MsidbDialogAttributesUseCustomPalette;
+                            }
+                            break;
+                        case "ErrorDialog":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                bits ^= MsiInterop.MsidbDialogAttributesError;
+                            }
+                            break;
+                        case "Hidden":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                bits ^= MsiInterop.MsidbDialogAttributesVisible;
+                            }
+                            break;
+                        case "KeepModeless":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                bits ^= MsiInterop.MsidbDialogAttributesKeepModeless;
+                            }
+                            break;
+                        case "LeftScroll":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                bits ^= MsiInterop.MsidbDialogAttributesLeftScroll;
+                            }
+                            break;
+                        case "Modeless":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                bits ^= MsiInterop.MsidbDialogAttributesModal;
+                            }
+                            break;
+                        case "NoMinimize":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                bits ^= MsiInterop.MsidbDialogAttributesMinimize;
+                            }
+                            break;
+                        case "RightAligned":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                bits ^= MsiInterop.MsidbDialogAttributesRightAligned;
+                            }
+                            break;
+                        case "RightToLeft":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                bits ^= MsiInterop.MsidbDialogAttributesRTLRO;
+                            }
+                            break;
+                        case "SystemModal":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                bits ^= MsiInterop.MsidbDialogAttributesSysModal;
+                            }
+                            break;
+                        case "TrackDiskSpace":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                bits ^= MsiInterop.MsidbDialogAttributesTrackDiskSpace;
+                                trackDiskSpace = true;
+                            }
+                            break;
+
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+                id = Identifier.Invalid;
+            }
+
+            Row lastTabRow = null;
+            string cancelControl = null;
+            string defaultControl = null;
+            string firstControl = null;
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "Control":
+                            this.ParseControlElement(child, id.Id, this.tableDefinitions["Control"], ref lastTabRow, ref firstControl, ref defaultControl, ref cancelControl, trackDiskSpace);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+
+            if (null != lastTabRow && null != lastTabRow[1])
+            {
+                if (firstControl != lastTabRow[1].ToString())
+                {
+                    lastTabRow[10] = firstControl;
+                }
+            }
+
+            if (null == firstControl)
+            {
+                this.core.OnMessage(WixErrors.NoFirstControlSpecified(sourceLineNumbers, id.Id));
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "Dialog", id);
+                row[1] = x;
+                row[2] = y;
+                row[3] = width;
+                row[4] = height;
+                row[5] = bits;
+                row[6] = title;
+                row[7] = firstControl;
+                row[8] = defaultControl;
+                row[9] = cancelControl;
+            }
+        }
+
+        /// <summary>
+        /// Parses an EmbeddedUI element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        private void ParseEmbeddedUIElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            string name = null;
+            int attributes = MsiInterop.MsidbEmbeddedUI; // by default this is the primary DLL that does not support basic UI.
+            int messageFilter = MsiInterop.INSTALLLOGMODE_FATALEXIT | MsiInterop.INSTALLLOGMODE_ERROR | MsiInterop.INSTALLLOGMODE_WARNING | MsiInterop.INSTALLLOGMODE_USER
+                                    | MsiInterop.INSTALLLOGMODE_INFO | MsiInterop.INSTALLLOGMODE_FILESINUSE | MsiInterop.INSTALLLOGMODE_RESOLVESOURCE
+                                    | MsiInterop.INSTALLLOGMODE_OUTOFDISKSPACE | MsiInterop.INSTALLLOGMODE_ACTIONSTART | MsiInterop.INSTALLLOGMODE_ACTIONDATA
+                                    | MsiInterop.INSTALLLOGMODE_PROGRESS | MsiInterop.INSTALLLOGMODE_COMMONDATA | MsiInterop.INSTALLLOGMODE_INITIALIZE
+                                    | MsiInterop.INSTALLLOGMODE_TERMINATE | MsiInterop.INSTALLLOGMODE_SHOWDIALOG | MsiInterop.INSTALLLOGMODE_RMFILESINUSE
+                                    | MsiInterop.INSTALLLOGMODE_INSTALLSTART | MsiInterop.INSTALLLOGMODE_INSTALLEND;
+            string sourceFile = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Name":
+                            name = this.core.GetAttributeLongFilename(sourceLineNumbers, attrib, false);
+                            break;
+                        case "IgnoreFatalExit":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                messageFilter ^= MsiInterop.INSTALLLOGMODE_FATALEXIT;
+                            }
+                            break;
+                        case "IgnoreError":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                messageFilter ^= MsiInterop.INSTALLLOGMODE_ERROR;
+                            }
+                            break;
+                        case "IgnoreWarning":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                messageFilter ^= MsiInterop.INSTALLLOGMODE_WARNING;
+                            }
+                            break;
+                        case "IgnoreUser":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                messageFilter ^= MsiInterop.INSTALLLOGMODE_USER;
+                            }
+                            break;
+                        case "IgnoreInfo":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                messageFilter ^= MsiInterop.INSTALLLOGMODE_INFO;
+                            }
+                            break;
+                        case "IgnoreFilesInUse":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                messageFilter ^= MsiInterop.INSTALLLOGMODE_FILESINUSE;
+                            }
+                            break;
+                        case "IgnoreResolveSource":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                messageFilter ^= MsiInterop.INSTALLLOGMODE_RESOLVESOURCE;
+                            }
+                            break;
+                        case "IgnoreOutOfDiskSpace":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                messageFilter ^= MsiInterop.INSTALLLOGMODE_OUTOFDISKSPACE;
+                            }
+                            break;
+                        case "IgnoreActionStart":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                messageFilter ^= MsiInterop.INSTALLLOGMODE_ACTIONSTART;
+                            }
+                            break;
+                        case "IgnoreActionData":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                messageFilter ^= MsiInterop.INSTALLLOGMODE_ACTIONDATA;
+                            }
+                            break;
+                        case "IgnoreProgress":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                messageFilter ^= MsiInterop.INSTALLLOGMODE_PROGRESS;
+                            }
+                            break;
+                        case "IgnoreCommonData":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                messageFilter ^= MsiInterop.INSTALLLOGMODE_COMMONDATA;
+                            }
+                            break;
+                        case "IgnoreInitialize":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                messageFilter ^= MsiInterop.INSTALLLOGMODE_INITIALIZE;
+                            }
+                            break;
+                        case "IgnoreTerminate":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                messageFilter ^= MsiInterop.INSTALLLOGMODE_TERMINATE;
+                            }
+                            break;
+                        case "IgnoreShowDialog":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                messageFilter ^= MsiInterop.INSTALLLOGMODE_SHOWDIALOG;
+                            }
+                            break;
+                        case "IgnoreRMFilesInUse":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                messageFilter ^= MsiInterop.INSTALLLOGMODE_RMFILESINUSE;
+                            }
+                            break;
+                        case "IgnoreInstallStart":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                messageFilter ^= MsiInterop.INSTALLLOGMODE_INSTALLSTART;
+                            }
+                            break;
+                        case "IgnoreInstallEnd":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                messageFilter ^= MsiInterop.INSTALLLOGMODE_INSTALLEND;
+                            }
+                            break;
+                        case "SourceFile":
+                            sourceFile = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "SupportBasicUI":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= MsiInterop.MsidbEmbeddedHandlesBasic;
+                            }
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (String.IsNullOrEmpty(sourceFile))
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "SourceFile"));
+            }
+            else if (String.IsNullOrEmpty(name))
+            {
+                name = Path.GetFileName(sourceFile);
+                if (!this.core.IsValidLongFilename(name, false))
+                {
+                    this.core.OnMessage(WixErrors.IllegalLongFilename(sourceLineNumbers, node.Name.LocalName, "Source", name));
+                }
+            }
+
+            if (null == id)
+            {
+                if (!String.IsNullOrEmpty(name))
+                {
+                    id = this.core.CreateIdentifierFromFilename(name);
+                }
+
+                if (null == id)
+                {
+                    this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+                }
+                else if (!Common.IsIdentifier(id.Id))
+                {
+                    this.core.OnMessage(WixErrors.IllegalIdentifier(sourceLineNumbers, node.Name.LocalName, "Id", id.Id));
+                }
+            }
+            else if (String.IsNullOrEmpty(name))
+            {
+                name = id.Id;
+            }
+
+            if (!name.Contains("."))
+            {
+                this.core.OnMessage(WixErrors.InvalidEmbeddedUIFileName(sourceLineNumbers, name));
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "EmbeddedUIResource":
+                            this.ParseEmbeddedUIResourceElement(child);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "MsiEmbeddedUI", id);
+                row[1] = name;
+                row[2] = attributes;
+                row[3] = messageFilter;
+                row[4] = sourceFile;
+            }
+        }
+
+        /// <summary>
+        /// Parses a embedded UI resource element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="parentId">Identifier of parent EmbeddedUI element.</param>
+        private void ParseEmbeddedUIResourceElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            string name = null;
+            string sourceFile = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Name":
+                            name = this.core.GetAttributeLongFilename(sourceLineNumbers, attrib, false);
+                            break;
+                        case "SourceFile":
+                            sourceFile = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (String.IsNullOrEmpty(sourceFile))
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "SourceFile"));
+            }
+            else if (String.IsNullOrEmpty(name))
+            {
+                name = Path.GetFileName(sourceFile);
+                if (!this.core.IsValidLongFilename(name, false))
+                {
+                    this.core.OnMessage(WixErrors.IllegalLongFilename(sourceLineNumbers, node.Name.LocalName, "Source", name));
+                }
+            }
+
+            if (null == id)
+            {
+                if (!String.IsNullOrEmpty(name))
+                {
+                    id = this.core.CreateIdentifierFromFilename(name);
+                }
+
+                if (null == id)
+                {
+                    this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+                }
+                else if (!Common.IsIdentifier(id.Id))
+                {
+                    this.core.OnMessage(WixErrors.IllegalIdentifier(sourceLineNumbers, node.Name.LocalName, "Id", id.Id));
+                }
+            }
+            else if (String.IsNullOrEmpty(name))
+            {
+                name = id.Id;
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "MsiEmbeddedUI", id);
+                row[1] = name;
+                row[2] = 0; // embedded UI resources always set this to 0
+                row[3] = null;
+                row[4] = sourceFile;
+            }
+        }
+
+        /// <summary>
+        /// Parses a control element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="dialog">Identifier for parent dialog.</param>
+        /// <param name="table">Table control belongs in.</param>
+        /// <param name="lastTabRow">Last row in the tab order.</param>
+        /// <param name="firstControl">Name of the first control in the tab order.</param>
+        /// <param name="defaultControl">Name of the default control.</param>
+        /// <param name="cancelControl">Name of the candle control.</param>
+        /// <param name="trackDiskSpace">True if the containing dialog tracks disk space.</param>
+        private void ParseControlElement(XElement node, string dialog, TableDefinition table, ref Row lastTabRow, ref string firstControl, ref string defaultControl, ref string cancelControl, bool trackDiskSpace)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            BitArray bits = new BitArray(32);
+            int attributes = 0;
+            string checkBoxPropertyRef = null;
+            string checkboxValue = null;
+            string controlType = null;
+            bool disabled = false;
+            string height = null;
+            string help = null;
+            bool isCancel = false;
+            bool isDefault = false;
+            bool notTabbable = false;
+            string property = null;
+            int publishOrder = 0;
+            string[] specialAttributes = null;
+            string sourceFile = null;
+            string text = null;
+            string tooltip = null;
+            RadioButtonType radioButtonsType = RadioButtonType.NotSet;
+            string width = null;
+            string x = null;
+            string y = null;
+
+            // The rest of the method relies on the control's Type, so we have to get that first.
+            XAttribute typeAttribute = node.Attribute("Type");
+            if (null == typeAttribute)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Type"));
+            }
+            else
+            {
+                controlType = this.core.GetAttributeValue(sourceLineNumbers, typeAttribute);
+            }
+
+            switch (controlType)
+            {
+                case "Billboard":
+                    specialAttributes = null;
+                    notTabbable = true;
+                    disabled = true;
+
+                    this.core.EnsureTable(sourceLineNumbers, "Billboard");
+                    break;
+                case "Bitmap":
+                    specialAttributes = MsiInterop.BitmapControlAttributes;
+                    notTabbable = true;
+                    disabled = true;
+                    break;
+                case "CheckBox":
+                    specialAttributes = MsiInterop.CheckboxControlAttributes;
+                    break;
+                case "ComboBox":
+                    specialAttributes = MsiInterop.ComboboxControlAttributes;
+                    break;
+                case "DirectoryCombo":
+                    specialAttributes = MsiInterop.VolumeControlAttributes;
+                    break;
+                case "DirectoryList":
+                    specialAttributes = null;
+                    break;
+                case "Edit":
+                    specialAttributes = MsiInterop.EditControlAttributes;
+                    break;
+                case "GroupBox":
+                    specialAttributes = null;
+                    notTabbable = true;
+                    break;
+                case "Hyperlink":
+                    specialAttributes = MsiInterop.HyperlinkControlAttributes;
+                    break;
+                case "Icon":
+                    specialAttributes = MsiInterop.IconControlAttributes;
+                    notTabbable = true;
+                    disabled = true;
+                    break;
+                case "Line":
+                    specialAttributes = null;
+                    notTabbable = true;
+                    disabled = true;
+                    break;
+                case "ListBox":
+                    specialAttributes = MsiInterop.ListboxControlAttributes;
+                    break;
+                case "ListView":
+                    specialAttributes = MsiInterop.ListviewControlAttributes;
+                    break;
+                case "MaskedEdit":
+                    specialAttributes = MsiInterop.EditControlAttributes;
+                    break;
+                case "PathEdit":
+                    specialAttributes = MsiInterop.EditControlAttributes;
+                    break;
+                case "ProgressBar":
+                    specialAttributes = MsiInterop.ProgressControlAttributes;
+                    notTabbable = true;
+                    disabled = true;
+                    break;
+                case "PushButton":
+                    specialAttributes = MsiInterop.ButtonControlAttributes;
+                    break;
+                case "RadioButtonGroup":
+                    specialAttributes = MsiInterop.RadioControlAttributes;
+                    break;
+                case "ScrollableText":
+                    specialAttributes = null;
+                    break;
+                case "SelectionTree":
+                    specialAttributes = null;
+                    break;
+                case "Text":
+                    specialAttributes = MsiInterop.TextControlAttributes;
+                    notTabbable = true;
+                    break;
+                case "VolumeCostList":
+                    specialAttributes = MsiInterop.VolumeControlAttributes;
+                    notTabbable = true;
+                    break;
+                case "VolumeSelectCombo":
+                    specialAttributes = MsiInterop.VolumeControlAttributes;
+                    break;
+                default:
+                    specialAttributes = null;
+                    notTabbable = true;
+                    break;
+            }
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Type": // already processed
+                            break;
+                        case "Cancel":
+                            isCancel = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "CheckBoxPropertyRef":
+                            checkBoxPropertyRef = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "CheckBoxValue":
+                            checkboxValue = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Default":
+                            isDefault = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Height":
+                            height = this.core.GetAttributeLocalizableIntegerValue(sourceLineNumbers, attrib, 0, short.MaxValue);
+                            break;
+                        case "Help":
+                            help = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "IconSize":
+                            string iconSizeValue = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (null != specialAttributes)
+                            {
+                                if (0 < iconSizeValue.Length)
+                                {
+                                    Wix.Control.IconSizeType iconsSizeType = Wix.Control.ParseIconSizeType(iconSizeValue);
+                                    switch (iconsSizeType)
+                                    {
+                                        case Wix.Control.IconSizeType.Item16:
+                                            this.core.TrySetBitFromName(specialAttributes, "Icon16", YesNoType.Yes, bits, 16);
+                                            break;
+                                        case Wix.Control.IconSizeType.Item32:
+                                            this.core.TrySetBitFromName(specialAttributes, "Icon32", YesNoType.Yes, bits, 16);
+                                            break;
+                                        case Wix.Control.IconSizeType.Item48:
+                                            this.core.TrySetBitFromName(specialAttributes, "Icon16", YesNoType.Yes, bits, 16);
+                                            this.core.TrySetBitFromName(specialAttributes, "Icon32", YesNoType.Yes, bits, 16);
+                                            break;
+                                        default:
+                                            this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, iconSizeValue, "16", "32", "48"));
+                                            break;
+                                    }
+                                }
+                            }
+                            else
+                            {
+                                this.core.OnMessage(WixErrors.IllegalAttributeValueWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, iconSizeValue, "Type"));
+                            }
+                            break;
+                        case "Property":
+                            property = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "TabSkip":
+                            notTabbable = YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Text":
+                            text = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ToolTip":
+                            tooltip = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Width":
+                            width = this.core.GetAttributeLocalizableIntegerValue(sourceLineNumbers, attrib, 0, short.MaxValue);
+                            break;
+                        case "X":
+                            x = this.core.GetAttributeLocalizableIntegerValue(sourceLineNumbers, attrib, 0, short.MaxValue);
+                            break;
+                        case "Y":
+                            y = this.core.GetAttributeLocalizableIntegerValue(sourceLineNumbers, attrib, 0, short.MaxValue);
+                            break;
+                        default:
+                            YesNoType attribValue = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            if (!this.core.TrySetBitFromName(MsiInterop.CommonControlAttributes, attrib.Name.LocalName, attribValue, bits, 0))
+                            {
+                                if (null == specialAttributes || !this.core.TrySetBitFromName(specialAttributes, attrib.Name.LocalName, attribValue, bits, 16))
+                                {
+                                    this.core.UnexpectedAttribute(node, attrib);
+                                }
+                            }
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            attributes = this.core.CreateIntegerFromBitArray(bits);
+
+            if (disabled)
+            {
+                attributes |= MsiInterop.MsidbControlAttributesEnabled; // bit will be inverted when stored
+            }
+
+            if (null == height)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Height"));
+            }
+
+            if (null == width)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Width"));
+            }
+
+            if (null == x)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "X"));
+            }
+
+            if (null == y)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Y"));
+            }
+
+            if (null == id)
+            {
+                id = this.core.CreateIdentifier("ctl", dialog, x, y, height, width);
+            }
+
+            if (isCancel)
+            {
+                cancelControl = id.Id;
+            }
+
+            if (isDefault)
+            {
+                defaultControl = id.Id;
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    SourceLineNumber childSourceLineNumbers = Preprocessor.GetSourceLineNumbers(child);
+                    switch (child.Name.LocalName)
+                    {
+                        case "Binary":
+                            this.ParseBinaryElement(child);
+                            break;
+                        case "ComboBox":
+                            this.ParseControlGroupElement(child, this.tableDefinitions["ComboBox"], "ListItem");
+                            break;
+                        case "Condition":
+                            this.ParseConditionElement(child, node.Name.LocalName, id.Id, dialog);
+                            break;
+                        case "ListBox":
+                            this.ParseControlGroupElement(child, this.tableDefinitions["ListBox"], "ListItem");
+                            break;
+                        case "ListView":
+                            this.ParseControlGroupElement(child, this.tableDefinitions["ListView"], "ListItem");
+                            break;
+                        case "Property":
+                            this.ParsePropertyElement(child);
+                            break;
+                        case "Publish":
+                            this.ParsePublishElement(child, dialog ?? String.Empty, id.Id, ref publishOrder);
+                            break;
+                        case "RadioButtonGroup":
+                            radioButtonsType = this.ParseRadioButtonGroupElement(child, property, radioButtonsType);
+                            break;
+                        case "Subscribe":
+                            this.ParseSubscribeElement(child, dialog, id.Id);
+                            break;
+                        case "Text":
+                            foreach (XAttribute attrib in child.Attributes())
+                            {
+                                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                                {
+                                    switch (attrib.Name.LocalName)
+                                    {
+                                        case "SourceFile":
+                                            sourceFile = this.core.GetAttributeValue(childSourceLineNumbers, attrib);
+                                            break;
+                                        default:
+                                            this.core.UnexpectedAttribute(child, attrib);
+                                            break;
+                                    }
+                                }
+                                else
+                                {
+                                    this.core.ParseExtensionAttribute(child, attrib);
+                                }
+                            }
+
+                            text = Common.GetInnerText(child);
+                            if (!String.IsNullOrEmpty(text) && null != sourceFile)
+                            {
+                                this.core.OnMessage(WixErrors.IllegalAttributeWithInnerText(childSourceLineNumbers, child.Name.LocalName, "SourceFile"));
+                            }
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            // If the radio buttons have icons, then we need to add the icon attribute.
+            switch (radioButtonsType)
+            {
+                case RadioButtonType.Bitmap:
+                    attributes |= MsiInterop.MsidbControlAttributesBitmap;
+                    break;
+                case RadioButtonType.Icon:
+                    attributes |= MsiInterop.MsidbControlAttributesIcon;
+                    break;
+                case RadioButtonType.Text:
+                    // Text is the default so nothing needs to be added bits
+                    break;
+            }
+
+            // If we're tracking disk space, and this is a non-FormatSize Text control, and the text attribute starts with 
+            // '[' and ends with ']', add a space. It is not necessary for the whole string to be a property, just 
+            // those two characters matter.
+            if (trackDiskSpace && "Text" == controlType &&
+                MsiInterop.MsidbControlAttributesFormatSize != (attributes & MsiInterop.MsidbControlAttributesFormatSize) &&
+                null != text && text.StartsWith("[", StringComparison.Ordinal) && text.EndsWith("]", StringComparison.Ordinal))
+            {
+                text = String.Concat(text, " ");
+            }
+
+            // the logic for creating control rows is a little tricky because of the way tabable controls are set
+            Row row = null;
+            if (!this.core.EncounteredError)
+            {
+                if ("CheckBox" == controlType)
+                {
+                    if (String.IsNullOrEmpty(property) && String.IsNullOrEmpty(checkBoxPropertyRef))
+                    {
+                        this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Property", "CheckBoxPropertyRef", true));
+                    }
+                    else if (!String.IsNullOrEmpty(property) && !String.IsNullOrEmpty(checkBoxPropertyRef))
+                    {
+                        this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "Property", "CheckBoxPropertyRef"));
+                    }
+                    else if (!String.IsNullOrEmpty(property))
+                    {
+                        row = this.core.CreateRow(sourceLineNumbers, "CheckBox");
+                        row[0] = property;
+                        row[1] = checkboxValue;
+                    }
+                    else
+                    {
+                        this.core.CreateSimpleReference(sourceLineNumbers, "CheckBox", checkBoxPropertyRef);
+                    }
+                }
+
+                row = this.core.CreateRow(sourceLineNumbers, table.Name);
+                row.Access = id.Access;
+                row[0] = dialog;
+                row[1] = id.Id;
+                row[2] = controlType;
+                row[3] = x;
+                row[4] = y;
+                row[5] = width;
+                row[6] = height;
+                row[7] = attributes ^ (MsiInterop.MsidbControlAttributesVisible | MsiInterop.MsidbControlAttributesEnabled);
+                if ("BBControl" == table.Name)
+                {
+                    row[8] = text; // BBControl.Text
+
+                    if (null != sourceFile)
+                    {
+                        Row wixBBControlRow = this.core.CreateRow(sourceLineNumbers, "WixBBControl");
+                        wixBBControlRow.Access = id.Access;
+                        wixBBControlRow[0] = dialog;
+                        wixBBControlRow[1] = id.Id;
+                        wixBBControlRow[2] = sourceFile;
+                    }
+                }
+                else
+                {
+                    row[8] = !String.IsNullOrEmpty(property) ? property : checkBoxPropertyRef;
+                    row[9] = text;
+                    if (null != tooltip || null != help)
+                    {
+                        row[11] = String.Concat(tooltip, "|", help); // Separator is required, even if only one is non-null.
+                    }
+
+                    if (null != sourceFile)
+                    {
+                        Row wixControlRow = this.core.CreateRow(sourceLineNumbers, "WixControl");
+                        wixControlRow.Access = id.Access;
+                        wixControlRow[0] = dialog;
+                        wixControlRow[1] = id.Id;
+                        wixControlRow[2] = sourceFile;
+                    }
+                }
+            }
+
+            if (!notTabbable)
+            {
+                if ("BBControl" == table.Name)
+                {
+                    this.core.OnMessage(WixErrors.TabbableControlNotAllowedInBillboard(sourceLineNumbers, node.Name.LocalName, controlType));
+                }
+
+                if (null == firstControl)
+                {
+                    firstControl = id.Id;
+                }
+
+                if (null != lastTabRow)
+                {
+                    lastTabRow[10] = id.Id;
+                }
+                lastTabRow = row;
+            }
+
+            // bitmap and icon controls contain a foreign key into the binary table in the text column;
+            // add a reference if the identifier of the binary entry is known during compilation
+            if (("Bitmap" == controlType || "Icon" == controlType) && Common.IsIdentifier(text))
+            {
+                this.core.CreateSimpleReference(sourceLineNumbers, "Binary", text);
+            }
+        }
+
+        /// <summary>
+        /// Parses a publish control event element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="dialog">Identifier of parent dialog.</param>
+        /// <param name="control">Identifier of parent control.</param>
+        /// <param name="order">Relative order of controls.</param>
+        private void ParsePublishElement(XElement node, string dialog, string control, ref int order)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string argument = null;
+            string condition = null;
+            string controlEvent = null;
+            string property = null;
+
+            // give this control event a unique ordering
+            order++;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Control":
+                            if (null != control)
+                            {
+                                this.core.OnMessage(WixErrors.IllegalAttributeWhenNested(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, node.Parent.Name.LocalName));
+                            }
+                            control = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Dialog":
+                            if (null != dialog)
+                            {
+                                this.core.OnMessage(WixErrors.IllegalAttributeWhenNested(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, node.Parent.Name.LocalName));
+                            }
+                            dialog = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.core.CreateSimpleReference(sourceLineNumbers, "Dialog", dialog);
+                            break;
+                        case "Event":
+                            controlEvent = Compiler.UppercaseFirstChar(this.core.GetAttributeValue(sourceLineNumbers, attrib));
+                            break;
+                        case "Order":
+                            order = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, 2147483647);
+                            break;
+                        case "Property":
+                            property = String.Concat("[", this.core.GetAttributeValue(sourceLineNumbers, attrib), "]");
+                            break;
+                        case "Value":
+                            argument = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            condition = this.core.GetConditionInnerText(node);
+
+            if (null == control)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Control"));
+            }
+
+            if (null == dialog)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Dialog"));
+            }
+
+            if (null == controlEvent && null == property) // need to specify at least one
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttributes(sourceLineNumbers, node.Name.LocalName, "Event", "Property"));
+            }
+            else if (null != controlEvent && null != property) // cannot specify both
+            {
+                this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "Event", "Property"));
+            }
+
+            if (null == argument)
+            {
+                if (null != controlEvent)
+                {
+                    this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Value", "Event"));
+                }
+                else if (null != property)
+                {
+                    // if this is setting a property to null, put a special value in the argument column
+                    argument = "{}";
+                }
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "ControlEvent");
+                row[0] = dialog;
+                row[1] = control;
+                row[2] = (null != controlEvent ? controlEvent : property);
+                row[3] = argument;
+                row[4] = condition;
+                row[5] = order;
+            }
+
+            if ("DoAction" == controlEvent && null != argument)
+            {
+                // if we're not looking at a standard action or a formatted string then create a reference 
+                // to the custom action.
+                if (!WindowsInstallerStandard.IsStandardAction(argument) && !Common.ContainsProperty(argument))
+                {
+                    this.core.CreateSimpleReference(sourceLineNumbers, "CustomAction", argument);
+                }
+            }
+
+            // if we're referring to a dialog but not through a property, add it to the references
+            if (("NewDialog" == controlEvent || "SpawnDialog" == controlEvent || "SpawnWaitDialog" == controlEvent || "SelectionBrowse" == controlEvent) && Common.IsIdentifier(argument))
+            {
+                this.core.CreateSimpleReference(sourceLineNumbers, "Dialog", argument);
+            }
+        }
+
+        /// <summary>
+        /// Parses a control subscription element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="dialog">Identifier of dialog.</param>
+        /// <param name="control">Identifier of control.</param>
+        private void ParseSubscribeElement(XElement node, string dialog, string control)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string controlAttribute = null;
+            string eventMapping = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Attribute":
+                            controlAttribute = Compiler.UppercaseFirstChar(this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib));
+                            break;
+                        case "Event":
+                            eventMapping = Compiler.UppercaseFirstChar(this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib));
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "EventMapping");
+                row[0] = dialog;
+                row[1] = control;
+                row[2] = eventMapping;
+                row[3] = controlAttribute;
+            }
+        }
+
+        /// <summary>
+        /// Parses an upgrade element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        private void ParseUpgradeElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string id = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeGuidValue(sourceLineNumbers, attrib, false);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            // process the UpgradeVersion children here
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    SourceLineNumber childSourceLineNumbers = Preprocessor.GetSourceLineNumbers(child);
+
+                    switch (child.Name.LocalName)
+                    {
+                        case "Property":
+                            this.ParsePropertyElement(child);
+                            this.core.OnMessage(WixWarnings.DeprecatedUpgradeProperty(childSourceLineNumbers));
+                            break;
+                        case "UpgradeVersion":
+                            this.ParseUpgradeVersionElement(child, id);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+
+            // No rows created here. All row creation is done in ParseUpgradeVersionElement.
+        }
+
+        /// <summary>
+        /// Parse upgrade version element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="upgradeId">Upgrade code.</param>
+        private void ParseUpgradeVersionElement(XElement node, string upgradeId)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+
+            string actionProperty = null;
+            string language = null;
+            string maximum = null;
+            string minimum = null;
+            int options = 256;
+            string removeFeatures = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "ExcludeLanguages":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                options |= MsiInterop.MsidbUpgradeAttributesLanguagesExclusive;
+                            }
+                            break;
+                        case "IgnoreRemoveFailure":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                options |= MsiInterop.MsidbUpgradeAttributesIgnoreRemoveFailure;
+                            }
+                            break;
+                        case "IncludeMaximum":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                options |= MsiInterop.MsidbUpgradeAttributesVersionMaxInclusive;
+                            }
+                            break;
+                        case "IncludeMinimum": // this is "yes" by default
+                            if (YesNoType.No == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                options &= ~MsiInterop.MsidbUpgradeAttributesVersionMinInclusive;
+                            }
+                            break;
+                        case "Language":
+                            language = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Minimum":
+                            minimum = this.core.GetAttributeVersionValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Maximum":
+                            maximum = this.core.GetAttributeVersionValue(sourceLineNumbers, attrib);
+                            break;
+                        case "MigrateFeatures":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                options |= MsiInterop.MsidbUpgradeAttributesMigrateFeatures;
+                            }
+                            break;
+                        case "OnlyDetect":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                options |= MsiInterop.MsidbUpgradeAttributesOnlyDetect;
+                            }
+                            break;
+                        case "Property":
+                            actionProperty = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        case "RemoveFeatures":
+                            removeFeatures = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == actionProperty)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Property"));
+            }
+            else if (actionProperty.ToUpper(CultureInfo.InvariantCulture) != actionProperty)
+            {
+                this.core.OnMessage(WixErrors.SecurePropertyNotUppercase(sourceLineNumbers, node.Name.LocalName, "Property", actionProperty));
+            }
+
+            if (null == minimum && null == maximum)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttributes(sourceLineNumbers, node.Name.LocalName, "Minimum", "Maximum"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "Upgrade");
+                row[0] = upgradeId;
+                row[1] = minimum;
+                row[2] = maximum;
+                row[3] = language;
+                row[4] = options;
+                row[5] = removeFeatures;
+                row[6] = actionProperty;
+
+                // Ensure the action property is secure.
+                this.AddWixPropertyRow(sourceLineNumbers, new Identifier(actionProperty, AccessModifier.Private), false, true, false);
+
+                // Ensure that RemoveExistingProducts is authored in InstallExecuteSequence
+                // if at least one row in Upgrade table lacks the OnlyDetect attribute.
+                if (0 == (options & MsiInterop.MsidbUpgradeAttributesOnlyDetect))
+                {
+                    this.core.CreateSimpleReference(sourceLineNumbers, "WixAction", "InstallExecuteSequence", "RemoveExistingProducts");
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses a verb element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="extension">Extension verb is releated to.</param>
+        /// <param name="progId">Optional progId for extension.</param>
+        /// <param name="componentId">Identifier for parent component.</param>
+        /// <param name="advertise">Flag if verb is advertised.</param>
+        private void ParseVerbElement(XElement node, string extension, string progId, string componentId, YesNoType advertise)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string id = null;
+            string argument = null;
+            string command = null;
+            int sequence = CompilerConstants.IntegerNotSet;
+            string target = null;
+            string targetFile = null;
+            string targetProperty = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Argument":
+                            argument = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Command":
+                            command = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Sequence":
+                            sequence = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 1, short.MaxValue);
+                            break;
+                        case "Target":
+                            target = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            this.core.OnMessage(WixWarnings.DeprecatedAttribute(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, "TargetFile", "TargetProperty"));
+                            break;
+                        case "TargetFile":
+                            targetFile = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            this.core.CreateSimpleReference(sourceLineNumbers, "File", targetFile);
+                            break;
+                        case "TargetProperty":
+                            targetProperty = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            if (null != target && null != targetFile)
+            {
+                this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "Target", "TargetFile"));
+            }
+
+            if (null != target && null != targetProperty)
+            {
+                this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "Target", "TargetProperty"));
+            }
+
+            if (null != targetFile && null != targetProperty)
+            {
+                this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "TargetFile", "TargetProperty"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (YesNoType.Yes == advertise)
+            {
+                if (null != target)
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeWhenAdvertised(sourceLineNumbers, node.Name.LocalName, "Target"));
+                }
+
+                if (null != targetFile)
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeWhenAdvertised(sourceLineNumbers, node.Name.LocalName, "TargetFile"));
+                }
+
+                if (null != targetProperty)
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeWhenAdvertised(sourceLineNumbers, node.Name.LocalName, "TargetProperty"));
+                }
+
+                if (!this.core.EncounteredError)
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "Verb");
+                    row[0] = extension;
+                    row[1] = id;
+                    if (CompilerConstants.IntegerNotSet != sequence)
+                    {
+                        row[2] = sequence;
+                    }
+                    row[3] = command;
+                    row[4] = argument;
+                }
+            }
+            else if (YesNoType.No == advertise)
+            {
+                if (CompilerConstants.IntegerNotSet != sequence)
+                {
+                    this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "Sequence", "Advertise", "no"));
+                }
+
+                if (null == target && null == targetFile && null == targetProperty)
+                {
+                    this.core.OnMessage(WixErrors.ExpectedAttributesWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "TargetFile", "TargetProperty", "Advertise", "no"));
+                }
+
+                if (null == target)
+                {
+                    if (null != targetFile)
+                    {
+                        target = String.Concat("\"[#", targetFile, "]\"");
+                    }
+
+                    if (null != targetProperty)
+                    {
+                        target = String.Concat("\"[", targetProperty, "]\"");
+                    }
+                }
+
+                if (null != argument)
+                {
+                    target = String.Concat(target, " ", argument);
+                }
+
+                string prefix = (null != progId ? progId : String.Concat(".", extension));
+
+                if (null != command)
+                {
+                    this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat(prefix, "\\shell\\", id), String.Empty, command, componentId);
+                }
+
+                this.core.CreateRegistryRow(sourceLineNumbers, MsiInterop.MsidbRegistryRootClassesRoot, String.Concat(prefix, "\\shell\\", id, "\\command"), String.Empty, target, componentId);
+            }
+        }
+
+
+        /// <summary>
+        /// Parses an ApprovedExeForElevation element.
+        /// </summary>
+        /// <param name="node">Element to parse</param>
+        private void ParseApprovedExeForElevation(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            string key = null;
+            string valueName = null;
+            YesNoType win64 = YesNoType.NotSet;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Key":
+                            key = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Value":
+                            valueName = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Win64":
+                            win64 = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            if (null == key)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Key"));
+            }
+
+            BundleApprovedExeForElevationAttributes attributes = BundleApprovedExeForElevationAttributes.None;
+
+            if (win64 == YesNoType.Yes)
+            {
+                attributes |= BundleApprovedExeForElevationAttributes.Win64;
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                WixApprovedExeForElevationRow wixApprovedExeForElevationRow = (WixApprovedExeForElevationRow)this.core.CreateRow(sourceLineNumbers, "WixApprovedExeForElevation", id);
+                wixApprovedExeForElevationRow.Key = key;
+                wixApprovedExeForElevationRow.ValueName = valueName;
+                wixApprovedExeForElevationRow.Attributes = attributes;
+            }
+        }
+
+        /// <summary>
+        /// Parses a Bundle element.
+        /// </summary>
+        /// <param name="node">Element to parse</param>
+        private void ParseBundleElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string copyright = null;
+            string aboutUrl = null;
+            YesNoDefaultType compressed = YesNoDefaultType.Default;
+            int disableModify = -1;
+            YesNoType disableRemove = YesNoType.NotSet;
+            string helpTelephone = null;
+            string helpUrl = null;
+            string manufacturer = null;
+            string name = null;
+            string tag = null;
+            string updateUrl = null;
+            string upgradeCode = null;
+            string version = null;
+            string condition = null;
+            string parentName = null;
+
+            string fileSystemSafeBundleName = null;
+            string logVariablePrefixAndExtension = null;
+            string iconSourceFile = null;
+            string splashScreenSourceFile = null;
+
+            // Process only standard attributes until the active section is initialized.
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "AboutUrl":
+                            aboutUrl = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Compressed":
+                            compressed = this.core.GetAttributeYesNoDefaultValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Condition":
+                            condition = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Copyright":
+                            copyright = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "DisableModify":
+                            string value = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            switch (value)
+                            {
+                                case "button":
+                                    disableModify = 2;
+                                    break;
+                                case "yes":
+                                    disableModify = 1;
+                                    break;
+                                case "no":
+                                    disableModify = 0;
+                                    break;
+                                default:
+                                    this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName, value, "button", "yes", "no"));
+                                    break;
+                            }
+                            break;
+                        case "DisableRemove":
+                            disableRemove = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "DisableRepair":
+                            this.core.OnMessage(WixWarnings.DeprecatedAttribute(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName));
+                            break;
+                        case "HelpTelephone":
+                            helpTelephone = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "HelpUrl":
+                            helpUrl = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Manufacturer":
+                            manufacturer = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "IconSourceFile":
+                            iconSourceFile = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Name":
+                            name = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ParentName":
+                            parentName = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "SplashScreenSourceFile":
+                            splashScreenSourceFile = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Tag":
+                            tag = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "UpdateUrl":
+                            updateUrl = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "UpgradeCode":
+                            upgradeCode = this.core.GetAttributeGuidValue(sourceLineNumbers, attrib, false);
+                            break;
+                        case "Version":
+                            version = this.core.GetAttributeVersionValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+            }
+
+            if (String.IsNullOrEmpty(version))
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Version"));
+            }
+            else if (!CompilerCore.IsValidModuleOrBundleVersion(version))
+            {
+                this.core.OnMessage(WixWarnings.InvalidModuleOrBundleVersion(sourceLineNumbers, "Bundle", version));
+            }
+
+            if (String.IsNullOrEmpty(upgradeCode))
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "UpgradeCode"));
+            }
+
+            if (String.IsNullOrEmpty(copyright))
+            {
+                if (String.IsNullOrEmpty(manufacturer))
+                {
+                    copyright = "Copyright (c). All rights reserved.";
+                }
+                else
+                {
+                    copyright = String.Format("Copyright (c) {0}. All rights reserved.", manufacturer);
+                }
+            }
+
+            if (String.IsNullOrEmpty(name))
+            {
+                logVariablePrefixAndExtension = String.Concat("WixBundleLog:Setup.log");
+            }
+            else
+            {
+                // Ensure only allowable path characters are in "name" (and change spaces to underscores).
+                fileSystemSafeBundleName = CompilerCore.MakeValidLongFileName(name.Replace(' ', '_'), "_");
+                logVariablePrefixAndExtension = String.Concat("WixBundleLog:", fileSystemSafeBundleName, ".log");
+            }
+
+            this.activeName = String.IsNullOrEmpty(name) ? Common.GenerateGuid() : name;
+            this.core.CreateActiveSection(this.activeName, SectionType.Bundle, 0);
+
+            // Now that the active section is initialized, process only extension attributes.
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (!String.IsNullOrEmpty(attrib.Name.NamespaceName) && CompilerCore.WixNamespace != attrib.Name.Namespace)
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            bool baSeen = false;
+            bool chainSeen = false;
+            bool logSeen = false;
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "ApprovedExeForElevation":
+                            this.ParseApprovedExeForElevation(child);
+                            break;
+                        case "BootstrapperApplication":
+                            if (baSeen)
+                            {
+                                SourceLineNumber childSourceLineNumbers = Preprocessor.GetSourceLineNumbers(child);
+                                this.core.OnMessage(WixErrors.TooManyChildren(childSourceLineNumbers, node.Name.LocalName, "BootstrapperApplication"));
+                            }
+                            this.ParseBootstrapperApplicationElement(child);
+                            baSeen = true;
+                            break;
+                        case "BootstrapperApplicationRef":
+                            this.ParseBootstrapperApplicationRefElement(child);
+                            break;
+                        case "OptionalUpdateRegistration":
+                            this.ParseOptionalUpdateRegistrationElement(child, manufacturer, parentName, name);
+                            break;
+                        case "Catalog":
+                            this.ParseCatalogElement(child);
+                            break;
+                        case "Chain":
+                            if (chainSeen)
+                            {
+                                SourceLineNumber childSourceLineNumbers = Preprocessor.GetSourceLineNumbers(child);
+                                this.core.OnMessage(WixErrors.TooManyChildren(childSourceLineNumbers, node.Name.LocalName, "Chain"));
+                            }
+                            this.ParseChainElement(child);
+                            chainSeen = true;
+                            break;
+                        case "Container":
+                            this.ParseContainerElement(child);
+                            break;
+                        case "ContainerRef":
+                            this.ParseSimpleRefElement(child, "WixBundleContainer");
+                            break;
+                        case "Log":
+                            if (logSeen)
+                            {
+                                SourceLineNumber childSourceLineNumbers = Preprocessor.GetSourceLineNumbers(child);
+                                this.core.OnMessage(WixErrors.TooManyChildren(childSourceLineNumbers, node.Name.LocalName, "Log"));
+                            }
+                            logVariablePrefixAndExtension = this.ParseLogElement(child, fileSystemSafeBundleName);
+                            logSeen = true;
+                            break;
+                        case "PayloadGroup":
+                            this.ParsePayloadGroupElement(child, ComplexReferenceParentType.Layout, "BundleLayoutOnlyPayloads");
+                            break;
+                        case "PayloadGroupRef":
+                            this.ParsePayloadGroupRefElement(child, ComplexReferenceParentType.Layout, "BundleLayoutOnlyPayloads", ComplexReferenceChildType.Unknown, null);
+                            break;
+                        case "RelatedBundle":
+                            this.ParseRelatedBundleElement(child);
+                            break;
+                        case "Update":
+                            this.ParseUpdateElement(child);
+                            break;
+                        case "Variable":
+                            this.ParseVariableElement(child);
+                            break;
+                        case "WixVariable":
+                            this.ParseWixVariableElement(child);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+
+            if (!chainSeen)
+            {
+                this.core.OnMessage(WixErrors.ExpectedElement(sourceLineNumbers, node.Name.LocalName, "Chain"));
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                if (null != upgradeCode)
+                {
+                    Row relatedBundleRow = this.core.CreateRow(sourceLineNumbers, "WixRelatedBundle");
+                    relatedBundleRow[0] = upgradeCode;
+                    relatedBundleRow[1] = (int)Wix.RelatedBundle.ActionType.Upgrade;
+                }
+
+                WixBundleContainerRow containerRow = (WixBundleContainerRow)this.core.CreateRow(sourceLineNumbers, "WixBundleContainer");
+                containerRow.Id = Compiler.BurnDefaultAttachedContainerId;
+                containerRow.Name = "bundle-attached.cab";
+                containerRow.Type = ContainerType.Attached;
+
+                Row row = this.core.CreateRow(sourceLineNumbers, "WixBundle");
+                row[0] = version;
+                row[1] = copyright;
+                row[2] = name;
+                row[3] = aboutUrl;
+                if (-1 != disableModify)
+                {
+                    row[4] = disableModify;
+                }
+                if (YesNoType.NotSet != disableRemove)
+                {
+                    row[5] = (YesNoType.Yes == disableRemove) ? 1 : 0;
+                }
+                // row[6] - (deprecated) "disable repair"
+                row[7] = helpTelephone;
+                row[8] = helpUrl;
+                row[9] = manufacturer;
+                row[10] = updateUrl;
+                if (YesNoDefaultType.Default != compressed)
+                {
+                    row[11] = (YesNoDefaultType.Yes == compressed) ? 1 : 0;
+                }
+
+                row[12] = logVariablePrefixAndExtension;
+                row[13] = iconSourceFile;
+                row[14] = splashScreenSourceFile;
+                row[15] = condition;
+                row[16] = tag;
+                row[17] = this.CurrentPlatform.ToString();
+                row[18] = parentName;
+                row[19] = upgradeCode;
+
+                // Ensure that the bundle stores the well-known persisted values.
+                WixBundleVariableRow bundleNameWellKnownVariable = (WixBundleVariableRow)this.core.CreateRow(sourceLineNumbers, "WixBundleVariable");
+                bundleNameWellKnownVariable.Id = Compiler.BURN_BUNDLE_NAME;
+                bundleNameWellKnownVariable.Hidden = false;
+                bundleNameWellKnownVariable.Persisted = true;
+
+                WixBundleVariableRow bundleOriginalSourceWellKnownVariable = (WixBundleVariableRow)this.core.CreateRow(sourceLineNumbers, "WixBundleVariable");
+                bundleOriginalSourceWellKnownVariable.Id = Compiler.BURN_BUNDLE_ORIGINAL_SOURCE;
+                bundleOriginalSourceWellKnownVariable.Hidden = false;
+                bundleOriginalSourceWellKnownVariable.Persisted = true;
+
+                WixBundleVariableRow bundleOriginalSourceFolderWellKnownVariable = (WixBundleVariableRow)this.core.CreateRow(sourceLineNumbers, "WixBundleVariable");
+                bundleOriginalSourceFolderWellKnownVariable.Id = Compiler.BURN_BUNDLE_ORIGINAL_SOURCE_FOLDER;
+                bundleOriginalSourceFolderWellKnownVariable.Hidden = false;
+                bundleOriginalSourceFolderWellKnownVariable.Persisted = true;
+
+                WixBundleVariableRow bundleLastUsedSourceWellKnownVariable = (WixBundleVariableRow)this.core.CreateRow(sourceLineNumbers, "WixBundleVariable");
+                bundleLastUsedSourceWellKnownVariable.Id = Compiler.BURN_BUNDLE_LAST_USED_SOURCE;
+                bundleLastUsedSourceWellKnownVariable.Hidden = false;
+                bundleLastUsedSourceWellKnownVariable.Persisted = true;
+            }
+        }
+
+        /// <summary>
+        /// Parse a Container element.
+        /// </summary>
+        /// <param name="node">Element to parse</param>
+        private string ParseLogElement(XElement node, string fileSystemSafeBundleName)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            YesNoType disableLog = YesNoType.NotSet;
+            string variable = "WixBundleLog";
+            string logPrefix = fileSystemSafeBundleName ?? "Setup";
+            string logExtension = ".log";
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Disable":
+                            disableLog = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "PathVariable":
+                            variable = this.core.GetAttributeValue(sourceLineNumbers, attrib, EmptyRule.CanBeEmpty);
+                            break;
+                        case "Prefix":
+                            logPrefix = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Extension":
+                            logExtension = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (!logExtension.StartsWith(".", StringComparison.Ordinal))
+            {
+                logExtension = String.Concat(".", logExtension);
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            return YesNoType.Yes == disableLog ? null : String.Concat(variable, ":", logPrefix, logExtension);
+        }
+
+        /// <summary>
+        /// Parse a Catalog element.
+        /// </summary>
+        /// <param name="node">Element to parse</param>
+        private void ParseCatalogElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            string sourceFile = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "SourceFile":
+                            sourceFile = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            if (null == sourceFile)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "SourceFile"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            // Create catalog row
+            if (!this.core.EncounteredError)
+            {
+                this.CreatePayloadRow(sourceLineNumbers, id, Path.GetFileName(sourceFile), sourceFile, null, ComplexReferenceParentType.Container, Compiler.BurnUXContainerId, ComplexReferenceChildType.Unknown, null, YesNoDefaultType.Yes, YesNoType.Yes, null, null, null);
+
+                WixBundleCatalogRow wixCatalogRow = (WixBundleCatalogRow)this.core.CreateRow(sourceLineNumbers, "WixBundleCatalog", id);
+                wixCatalogRow.Payload = id.Id;
+            }
+        }
+
+        /// <summary>
+        /// Parse a Container element.
+        /// </summary>
+        /// <param name="node">Element to parse</param>
+        private void ParseContainerElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            string downloadUrl = null;
+            string name = null;
+            ContainerType type = ContainerType.Detached;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "DownloadUrl":
+                            downloadUrl = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Name":
+                            name = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Type":
+                            string typeString = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (!Enum.TryParse<ContainerType>(typeString, out type))
+                            {
+                                this.core.OnMessage(WixErrors.IllegalAttributeValueWithLegalList(sourceLineNumbers, node.Name.LocalName, "Type", typeString, "attached, detached"));
+                            }
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                if (!String.IsNullOrEmpty(name))
+                {
+                    id = this.core.CreateIdentifierFromFilename(name);
+                }
+
+                if (null == id)
+                {
+                    this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+                    id = Identifier.Invalid;
+                }
+                else if (!Common.IsIdentifier(id.Id))
+                {
+                    this.core.OnMessage(WixErrors.IllegalIdentifier(sourceLineNumbers, node.Name.LocalName, "Id", id.Id));
+                }
+            }
+            else if (null == name)
+            {
+                name = id.Id;
+            }
+
+            if (!String.IsNullOrEmpty(downloadUrl) && ContainerType.Detached != type)
+            {
+                this.core.OnMessage(WixErrors.IllegalAttributeWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "DownloadUrl", "Type", "attached"));
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "PackageGroupRef":
+                            this.ParsePackageGroupRefElement(child, ComplexReferenceParentType.Container, id.Id);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+
+            if (!this.core.EncounteredError)
+            {
+                WixBundleContainerRow row = (WixBundleContainerRow)this.core.CreateRow(sourceLineNumbers, "WixBundleContainer", id);
+                row.Name = name;
+                row.Type = type;
+                row.DownloadUrl = downloadUrl;
+            }
+        }
+
+        /// <summary>
+        /// Parse the BoostrapperApplication element.
+        /// </summary>
+        /// <param name="node">Element to parse</param>
+        private void ParseBootstrapperApplicationElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string id = null;
+            string previousId = null;
+            ComplexReferenceChildType previousType = ComplexReferenceChildType.Unknown;
+
+            // The BootstrapperApplication element acts like a Payload element so delegate to the "Payload" attribute parsing code to parse and create a Payload entry.
+            id = this.ParsePayloadElementContent(node, ComplexReferenceParentType.Container, Compiler.BurnUXContainerId, previousType, previousId, false);
+            if (null != id)
+            {
+                previousId = id;
+                previousType = ComplexReferenceChildType.Payload;
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "Payload":
+                            previousId = this.ParsePayloadElement(child, ComplexReferenceParentType.Container, Compiler.BurnUXContainerId, previousType, previousId);
+                            previousType = ComplexReferenceChildType.Payload;
+                            break;
+                        case "PayloadGroupRef":
+                            previousId = this.ParsePayloadGroupRefElement(child, ComplexReferenceParentType.Container, Compiler.BurnUXContainerId, previousType, previousId);
+                            previousType = ComplexReferenceChildType.PayloadGroup;
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+            if (null == previousId)
+            {
+                // We need *either* <Payload> or <PayloadGroupRef> or even just @SourceFile on the BA...
+                // but we just say there's a missing <Payload>.
+                // TODO: Is there a better message for this?
+                this.core.OnMessage(WixErrors.ExpectedElement(sourceLineNumbers, node.Name.LocalName, "Payload"));
+            }
+
+            // Add the application as an attached container and if an Id was provided add that too.
+            if (!this.core.EncounteredError)
+            {
+                WixBundleContainerRow containerRow = (WixBundleContainerRow)this.core.CreateRow(sourceLineNumbers, "WixBundleContainer");
+                containerRow.Id = Compiler.BurnUXContainerId;
+                containerRow.Name = "bundle-ux.cab";
+                containerRow.Type = ContainerType.Attached;
+
+                if (!String.IsNullOrEmpty(id))
+                {
+                    Row row = this.core.CreateRow(sourceLineNumbers, "WixBootstrapperApplication");
+                    row[0] = id;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parse the BoostrapperApplicationRef element.
+        /// </summary>
+        /// <param name="node">Element to parse</param>
+        private void ParseBootstrapperApplicationRefElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string id = null;
+            string previousId = null;
+            ComplexReferenceChildType previousType = ComplexReferenceChildType.Unknown;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "Payload":
+                            previousId = this.ParsePayloadElement(child, ComplexReferenceParentType.Container, Compiler.BurnUXContainerId, previousType, previousId);
+                            previousType = ComplexReferenceChildType.Payload;
+                            break;
+                        case "PayloadGroupRef":
+                            previousId = this.ParsePayloadGroupRefElement(child, ComplexReferenceParentType.Container, Compiler.BurnUXContainerId, previousType, previousId);
+                            previousType = ComplexReferenceChildType.PayloadGroup;
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+
+            if (String.IsNullOrEmpty(id))
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+            else
+            {
+                this.core.CreateSimpleReference(sourceLineNumbers, "WixBootstrapperApplication", id);
+            }
+        }
+
+        /// <summary>
+        /// Parse the OptionalUpdateRegistration element.
+        /// </summary>
+        /// <param name="node">The element to parse.</param>
+        /// <param name="defaultManufacturer">The manufacturer.</param>
+        /// <param name="defaultProductFamily">The product family.</param>
+        /// <param name="defaultName">The bundle name.</param>
+        private void ParseOptionalUpdateRegistrationElement(XElement node, string defaultManufacturer, string defaultProductFamily, string defaultName)
+        {
+            const string defaultClassification = "Update";
+
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string manufacturer = null;
+            string department = null;
+            string productFamily = null;
+            string name = null;
+            string classification = defaultClassification;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Manufacturer":
+                            manufacturer = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Department":
+                            department = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ProductFamily":
+                            productFamily = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Name":
+                            name = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Classification":
+                            classification = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (String.IsNullOrEmpty(manufacturer))
+            {
+                if (!String.IsNullOrEmpty(defaultManufacturer))
+                {
+                    manufacturer = defaultManufacturer;
+                }
+                else
+                {
+                    this.core.OnMessage(WixErrors.ExpectedAttributeInElementOrParent(sourceLineNumbers, node.Name.LocalName, "Manufacturer", node.Parent.Name.LocalName));
+                }
+            }
+
+            if (String.IsNullOrEmpty(productFamily))
+            {
+                if (!String.IsNullOrEmpty(defaultProductFamily))
+                {
+                    productFamily = defaultProductFamily;
+                }
+            }
+
+            if (String.IsNullOrEmpty(name))
+            {
+                if (!String.IsNullOrEmpty(defaultName))
+                {
+                    name = defaultName;
+                }
+                else
+                {
+                    this.core.OnMessage(WixErrors.ExpectedAttributeInElementOrParent(sourceLineNumbers, node.Name.LocalName, "Name", node.Parent.Name.LocalName));
+                }
+            }
+
+            if (String.IsNullOrEmpty(classification))
+            {
+                this.core.OnMessage(WixErrors.IllegalEmptyAttributeValue(sourceLineNumbers, node.Name.LocalName, "Classification", defaultClassification));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "WixUpdateRegistration");
+                row[0] = manufacturer;
+                row[1] = department;
+                row[2] = productFamily;
+                row[3] = name;
+                row[4] = classification;
+            }
+        }
+
+        /// <summary>
+        /// Parse Payload element.
+        /// </summary>
+        /// <param name="node">Element to parse</param>
+        /// <param name="parentType">ComplexReferenceParentType of parent element. (BA or PayloadGroup)</param>
+        /// <param name="parentId">Identifier of parent element.</param>
+        private string ParsePayloadElement(XElement node, ComplexReferenceParentType parentType, string parentId, ComplexReferenceChildType previousType, string previousId)
+        {
+            Debug.Assert(ComplexReferenceParentType.PayloadGroup == parentType || ComplexReferenceParentType.Package == parentType || ComplexReferenceParentType.Container == parentType);
+            Debug.Assert(ComplexReferenceChildType.Unknown == previousType || ComplexReferenceChildType.PayloadGroup == previousType || ComplexReferenceChildType.Payload == previousType);
+
+            string id = ParsePayloadElementContent(node, parentType, parentId, previousType, previousId, true);
+            Dictionary<string, string> context = new Dictionary<string, string>();
+            context["Id"] = id;
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child, context);
+                }
+            }
+
+            return id;
+        }
+
+        /// <summary>
+        /// Parse the attributes of the Payload element.
+        /// </summary>
+        /// <param name="node">Element to parse</param>
+        /// <param name="parentType">ComplexReferenceParentType of parent element.</param>
+        /// <param name="parentId">Identifier of parent element.</param>
+        private string ParsePayloadElementContent(XElement node, ComplexReferenceParentType parentType, string parentId, ComplexReferenceChildType previousType, string previousId, bool required)
+        {
+            Debug.Assert(ComplexReferenceParentType.PayloadGroup == parentType || ComplexReferenceParentType.Package == parentType || ComplexReferenceParentType.Container == parentType);
+
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            YesNoDefaultType compressed = YesNoDefaultType.Default;
+            YesNoType enableSignatureVerification = YesNoType.No;
+            Identifier id = null;
+            string name = null;
+            string sourceFile = null;
+            string downloadUrl = null;
+            Wix.RemotePayload remotePayload = null;
+
+            // This list lets us evaluate extension attributes *after* all core attributes
+            // have been parsed and dealt with, regardless of authoring order.
+            List<XAttribute> extensionAttributes = new List<XAttribute>();
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Compressed":
+                            compressed = this.core.GetAttributeYesNoDefaultValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Name":
+                            name = this.core.GetAttributeLongFilename(sourceLineNumbers, attrib, false, true);
+                            break;
+                        case "SourceFile":
+                            sourceFile = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "DownloadUrl":
+                            downloadUrl = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "EnableSignatureVerification":
+                            enableSignatureVerification = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    extensionAttributes.Add(attrib);
+                }
+            }
+
+            if (!required && null == sourceFile)
+            {
+                // Nothing left to do!
+                return null;
+            }
+
+            if (null == id)
+            {
+                id = this.core.CreateIdentifier("pay", (null != sourceFile) ? sourceFile.ToUpperInvariant() : String.Empty);
+            }
+
+            // Now that the PayloadId is known, we can parse the extension attributes.
+            Dictionary<string, string> context = new Dictionary<string, string>();
+            context["Id"] = id.Id;
+
+            foreach (XAttribute extensionAttribute in extensionAttributes)
+            {
+                this.core.ParseExtensionAttribute(node, extensionAttribute, context);
+            }
+
+            // We only handle the elements we care about.  Let caller handle other children.
+            foreach (XElement child in node.Elements(CompilerCore.WixNamespace + "RemotePayload"))
+            {
+                SourceLineNumber childSourceLineNumbers = Preprocessor.GetSourceLineNumbers(child);
+
+                if (CompilerCore.WixNamespace == node.Name.Namespace && node.Name.LocalName != "ExePackage")
+                {
+                    this.core.OnMessage(WixErrors.RemotePayloadUnsupported(childSourceLineNumbers));
+                    continue;
+                }
+
+                if (null != remotePayload)
+                {
+                    this.core.OnMessage(WixErrors.TooManyChildren(childSourceLineNumbers, node.Name.LocalName, child.Name.LocalName));
+                }
+
+                remotePayload = this.ParseRemotePayloadElement(child);
+            }
+
+            if (null != sourceFile && null != remotePayload)
+            {
+                this.core.OnMessage(WixErrors.UnexpectedElementWithAttribute(sourceLineNumbers, node.Name.LocalName, "RemotePayload", "SourceFile"));
+            }
+            else if (null == sourceFile && null == remotePayload)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttributeOrElement(sourceLineNumbers, node.Name.LocalName, "SourceFile", "RemotePayload"));
+            }
+            else if (null == sourceFile)
+            {
+                sourceFile = String.Empty;
+            }
+
+            if (null == downloadUrl && null != remotePayload)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttributeWithElement(sourceLineNumbers, node.Name.LocalName, "DownloadUrl", "RemotePayload"));
+            }
+
+            if (Compiler.BurnUXContainerId == parentId)
+            {
+                if (compressed == YesNoDefaultType.No)
+                {
+                    core.OnMessage(WixWarnings.UxPayloadsOnlySupportEmbedding(sourceLineNumbers, sourceFile));
+                }
+
+                compressed = YesNoDefaultType.Yes;
+            }
+
+            this.CreatePayloadRow(sourceLineNumbers, id, name, sourceFile, downloadUrl, parentType, parentId, previousType, previousId, compressed, enableSignatureVerification, null, null, remotePayload);
+
+            return id.Id;
+        }
+
+        private Wix.RemotePayload ParseRemotePayloadElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Wix.RemotePayload remotePayload = new Wix.RemotePayload();
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "CertificatePublicKey":
+                            remotePayload.CertificatePublicKey = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "CertificateThumbprint":
+                            remotePayload.CertificateThumbprint = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Description":
+                            remotePayload.Description = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Hash":
+                            remotePayload.Hash = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ProductName":
+                            remotePayload.ProductName = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Size":
+                            remotePayload.Size = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, int.MaxValue);
+                            break;
+                        case "Version":
+                            remotePayload.Version = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (String.IsNullOrEmpty(remotePayload.ProductName))
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "ProductName"));
+            }
+
+            if (String.IsNullOrEmpty(remotePayload.Description))
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Description"));
+            }
+
+            if (String.IsNullOrEmpty(remotePayload.Hash))
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Hash"));
+            }
+
+            if (0 == remotePayload.Size)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Size"));
+            }
+
+            if (String.IsNullOrEmpty(remotePayload.Version))
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Version"));
+            }
+
+            return remotePayload;
+        }
+
+        /// <summary>
+        /// Creates the row for a Payload.
+        /// </summary>
+        /// <param name="node">Element to parse</param>
+        /// <param name="parentType">ComplexReferenceParentType of parent element</param>
+        /// <param name="parentId">Identifier of parent element.</param>
+        private WixBundlePayloadRow CreatePayloadRow(SourceLineNumber sourceLineNumbers, Identifier id, string name, string sourceFile, string downloadUrl, ComplexReferenceParentType parentType,
+            string parentId, ComplexReferenceChildType previousType, string previousId, YesNoDefaultType compressed, YesNoType enableSignatureVerification, string displayName, string description,
+            Wix.RemotePayload remotePayload)
+        {
+            WixBundlePayloadRow row = null;
+
+            if (!this.core.EncounteredError)
+            {
+                row = (WixBundlePayloadRow)this.core.CreateRow(sourceLineNumbers, "WixBundlePayload", id);
+                row.Name = String.IsNullOrEmpty(name) ? Path.GetFileName(sourceFile) : name;
+                row.SourceFile = sourceFile;
+                row.DownloadUrl = downloadUrl;
+                row.Compressed = compressed;
+                row.UnresolvedSourceFile = sourceFile; // duplicate of sourceFile but in a string column so it won't get resolved to a full path during binding.
+                row.DisplayName = displayName;
+                row.Description = description;
+                row.EnableSignatureValidation = (YesNoType.Yes == enableSignatureVerification);
+
+                if (null != remotePayload)
+                {
+                    row.Description = remotePayload.Description;
+                    row.DisplayName = remotePayload.ProductName;
+                    row.Hash = remotePayload.Hash;
+                    row.PublicKey = remotePayload.CertificatePublicKey;
+                    row.Thumbprint = remotePayload.CertificateThumbprint;
+                    row.FileSize = remotePayload.Size;
+                    row.Version = remotePayload.Version;
+                }
+
+                this.CreateGroupAndOrderingRows(sourceLineNumbers, parentType, parentId, ComplexReferenceChildType.Payload, id.Id, previousType, previousId);
+            }
+
+            return row;
+        }
+
+        /// <summary>
+        /// Parse PayloadGroup element.
+        /// </summary>
+        /// <param name="node">Element to parse</param>
+        /// <param name="parentType">Optional ComplexReferenceParentType of parent element. (typically another PayloadGroup)</param>
+        /// <param name="parentId">Identifier of parent element.</param>
+        private void ParsePayloadGroupElement(XElement node, ComplexReferenceParentType parentType, string parentId)
+        {
+            Debug.Assert(ComplexReferenceParentType.Unknown == parentType || ComplexReferenceParentType.Layout == parentType || ComplexReferenceParentType.PayloadGroup == parentType);
+
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+                id = Identifier.Invalid;
+            }
+
+            ComplexReferenceChildType previousType = ComplexReferenceChildType.Unknown;
+            string previousId = null;
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "Payload":
+                            previousId = this.ParsePayloadElement(child, ComplexReferenceParentType.PayloadGroup, id.Id, previousType, previousId);
+                            previousType = ComplexReferenceChildType.Payload;
+                            break;
+                        case "PayloadGroupRef":
+                            previousId = this.ParsePayloadGroupRefElement(child, ComplexReferenceParentType.PayloadGroup, id.Id, previousType, previousId);
+                            previousType = ComplexReferenceChildType.PayloadGroup;
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+
+            if (!this.core.EncounteredError)
+            {
+                this.core.CreateRow(sourceLineNumbers, "WixBundlePayloadGroup", id);
+
+                this.CreateGroupAndOrderingRows(sourceLineNumbers, parentType, parentId, ComplexReferenceChildType.PayloadGroup, id.Id, ComplexReferenceChildType.Unknown, null);
+            }
+        }
+
+        /// <summary>
+        /// Parses a payload group reference element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="parentType">ComplexReferenceParentType of parent element (BA or PayloadGroup).</param>
+        /// <param name="parentId">Identifier of parent element.</param>
+        private string ParsePayloadGroupRefElement(XElement node, ComplexReferenceParentType parentType, string parentId, ComplexReferenceChildType previousType, string previousId)
+        {
+            Debug.Assert(ComplexReferenceParentType.Layout == parentType || ComplexReferenceParentType.PayloadGroup == parentType || ComplexReferenceParentType.Package == parentType || ComplexReferenceParentType.Container == parentType);
+            Debug.Assert(ComplexReferenceChildType.Unknown == previousType || ComplexReferenceChildType.PayloadGroup == previousType || ComplexReferenceChildType.Payload == previousType);
+
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string id = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.core.CreateSimpleReference(sourceLineNumbers, "WixBundlePayloadGroup", id);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            this.CreateGroupAndOrderingRows(sourceLineNumbers, parentType, parentId, ComplexReferenceChildType.PayloadGroup, id, previousType, previousId);
+
+            return id;
+        }
+
+        /// <summary>
+        /// Creates group and ordering information.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line numbers.</param>
+        /// <param name="parentType">Type of parent group, if known.</param>
+        /// <param name="parentId">Identifier of parent group, if known.</param>
+        /// <param name="type">Type of this item.</param>
+        /// <param name="id">Identifier for this item.</param>
+        /// <param name="previousType">Type of previous item, if known.</param>
+        /// <param name="previousId">Identifier of previous item, if known</param>
+        private void CreateGroupAndOrderingRows(SourceLineNumber sourceLineNumbers,
+            ComplexReferenceParentType parentType, string parentId,
+            ComplexReferenceChildType type, string id,
+            ComplexReferenceChildType previousType, string previousId)
+        {
+            if (ComplexReferenceParentType.Unknown != parentType && null != parentId)
+            {
+                this.core.CreateWixGroupRow(sourceLineNumbers, parentType, parentId, type, id);
+            }
+
+            if (ComplexReferenceChildType.Unknown != previousType && null != previousId)
+            {
+                this.CreateWixOrderingRow(sourceLineNumbers, type, id, previousType, previousId);
+            }
+        }
+
+        /// <summary>
+        /// Parse ExitCode element.
+        /// </summary>
+        /// <param name="node">Element to parse</param>
+        /// <param name="packageId">Id of parent element</param>
+        private void ParseExitCodeElement(XElement node, string packageId)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            int value = CompilerConstants.IntegerNotSet;
+            ExitCodeBehaviorType behavior = ExitCodeBehaviorType.NotSet;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Value":
+                            value = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, int.MinValue + 2, int.MaxValue);
+                            break;
+                        case "Behavior":
+                            string behaviorString = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (!Enum.TryParse<ExitCodeBehaviorType>(behaviorString, true, out behavior))
+                            {
+                                this.core.OnMessage(WixErrors.IllegalAttributeValueWithLegalList(sourceLineNumbers, node.Name.LocalName, "Behavior", behaviorString, "success, error, scheduleReboot, forceReboot"));
+                            }
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (ExitCodeBehaviorType.NotSet == behavior)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Behavior"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                WixBundlePackageExitCodeRow row = (WixBundlePackageExitCodeRow)this.core.CreateRow(sourceLineNumbers, "WixBundlePackageExitCode");
+                row.ChainPackageId = packageId;
+                row.Code = value;
+                row.Behavior = behavior;
+            }
+        }
+
+        /// <summary>
+        /// Parse Chain element.
+        /// </summary>
+        /// <param name="node">Element to parse</param>
+        private void ParseChainElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            WixChainAttributes attributes = WixChainAttributes.None;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "DisableRollback":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= WixChainAttributes.DisableRollback;
+                            }
+                            break;
+                        case "DisableSystemRestore":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= WixChainAttributes.DisableSystemRestore;
+                            }
+                            break;
+                        case "ParallelCache":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= WixChainAttributes.ParallelCache;
+                            }
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            // Ensure there is always a rollback boundary at the beginning of the chain.
+            this.CreateRollbackBoundary(sourceLineNumbers, new Identifier("WixDefaultBoundary", AccessModifier.Public), YesNoType.Yes, YesNoType.No, ComplexReferenceParentType.PackageGroup, "WixChain", ComplexReferenceChildType.Unknown, null);
+
+            string previousId = "WixDefaultBoundary";
+            ComplexReferenceChildType previousType = ComplexReferenceChildType.Package;
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "MsiPackage":
+                            previousId = this.ParseMsiPackageElement(child, ComplexReferenceParentType.PackageGroup, "WixChain", previousType, previousId);
+                            previousType = ComplexReferenceChildType.Package;
+                            break;
+                        case "MspPackage":
+                            previousId = this.ParseMspPackageElement(child, ComplexReferenceParentType.PackageGroup, "WixChain", previousType, previousId);
+                            previousType = ComplexReferenceChildType.Package;
+                            break;
+                        case "MsuPackage":
+                            previousId = this.ParseMsuPackageElement(child, ComplexReferenceParentType.PackageGroup, "WixChain", previousType, previousId);
+                            previousType = ComplexReferenceChildType.Package;
+                            break;
+                        case "ExePackage":
+                            previousId = this.ParseExePackageElement(child, ComplexReferenceParentType.PackageGroup, "WixChain", previousType, previousId);
+                            previousType = ComplexReferenceChildType.Package;
+                            break;
+                        case "RollbackBoundary":
+                            previousId = this.ParseRollbackBoundaryElement(child, ComplexReferenceParentType.PackageGroup, "WixChain", previousType, previousId);
+                            previousType = ComplexReferenceChildType.Package;
+                            break;
+                        case "PackageGroupRef":
+                            previousId = this.ParsePackageGroupRefElement(child, ComplexReferenceParentType.PackageGroup, "WixChain", previousType, previousId);
+                            previousType = ComplexReferenceChildType.PackageGroup;
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+
+            if (null == previousId)
+            {
+                this.core.OnMessage(WixErrors.ExpectedElement(sourceLineNumbers, node.Name.LocalName, "MsiPackage", "ExePackage", "PackageGroupRef"));
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                WixChainRow row = (WixChainRow)this.core.CreateRow(sourceLineNumbers, "WixChain");
+                row.Attributes = attributes;
+            }
+        }
+
+        /// <summary>
+        /// Parse MsiPackage element
+        /// </summary>
+        /// <param name="node">Element to parse</param>
+        /// <param name="parentType">Type of parent group, if known.</param>
+        /// <param name="parentId">Identifier of parent group, if known.</param>
+        /// <param name="previousType">Type of previous item, if known.</param>
+        /// <param name="previousId">Identifier of previous item, if known</param>
+        /// <returns>Identifier for package element.</returns>
+        private string ParseMsiPackageElement(XElement node, ComplexReferenceParentType parentType, string parentId, ComplexReferenceChildType previousType, string previousId)
+        {
+            return ParseChainPackage(node, WixBundlePackageType.Msi, parentType, parentId, previousType, previousId);
+        }
+
+        /// <summary>
+        /// Parse MspPackage element
+        /// </summary>
+        /// <param name="node">Element to parse</param>
+        /// <param name="parentType">Type of parent group, if known.</param>
+        /// <param name="parentId">Identifier of parent group, if known.</param>
+        /// <param name="previousType">Type of previous item, if known.</param>
+        /// <param name="previousId">Identifier of previous item, if known</param>
+        /// <returns>Identifier for package element.</returns>
+        private string ParseMspPackageElement(XElement node, ComplexReferenceParentType parentType, string parentId, ComplexReferenceChildType previousType, string previousId)
+        {
+            return ParseChainPackage(node, WixBundlePackageType.Msp, parentType, parentId, previousType, previousId);
+        }
+
+        /// <summary>
+        /// Parse MsuPackage element
+        /// </summary>
+        /// <param name="node">Element to parse</param>
+        /// <param name="parentType">Type of parent group, if known.</param>
+        /// <param name="parentId">Identifier of parent group, if known.</param>
+        /// <param name="previousType">Type of previous item, if known.</param>
+        /// <param name="previousId">Identifier of previous item, if known</param>
+        /// <returns>Identifier for package element.</returns>
+        private string ParseMsuPackageElement(XElement node, ComplexReferenceParentType parentType, string parentId, ComplexReferenceChildType previousType, string previousId)
+        {
+            return ParseChainPackage(node, WixBundlePackageType.Msu, parentType, parentId, previousType, previousId);
+        }
+
+        /// <summary>
+        /// Parse ExePackage element
+        /// </summary>
+        /// <param name="node">Element to parse</param>
+        /// <param name="parentType">Type of parent group, if known.</param>
+        /// <param name="parentId">Identifier of parent group, if known.</param>
+        /// <param name="previousType">Type of previous item, if known.</param>
+        /// <param name="previousId">Identifier of previous item, if known</param>
+        /// <returns>Identifier for package element.</returns>
+        private string ParseExePackageElement(XElement node, ComplexReferenceParentType parentType, string parentId, ComplexReferenceChildType previousType, string previousId)
+        {
+            return ParseChainPackage(node, WixBundlePackageType.Exe, parentType, parentId, previousType, previousId);
+        }
+
+        /// <summary>
+        /// Parse RollbackBoundary element
+        /// </summary>
+        /// <param name="node">Element to parse</param>
+        /// <param name="parentType">Type of parent group, if known.</param>
+        /// <param name="parentId">Identifier of parent group, if known.</param>
+        /// <param name="previousType">Type of previous item, if known.</param>
+        /// <param name="previousId">Identifier of previous item, if known</param>
+        /// <returns>Identifier for package element.</returns>
+        private string ParseRollbackBoundaryElement(XElement node, ComplexReferenceParentType parentType, string parentId, ComplexReferenceChildType previousType, string previousId)
+        {
+            Debug.Assert(ComplexReferenceParentType.PackageGroup == parentType);
+            Debug.Assert(ComplexReferenceChildType.Unknown == previousType || ComplexReferenceChildType.PackageGroup == previousType || ComplexReferenceChildType.Package == previousType);
+
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            YesNoType vital = YesNoType.Yes;
+            YesNoType transaction = YesNoType.No;
+
+            // This list lets us evaluate extension attributes *after* all core attributes
+            // have been parsed and dealt with, regardless of authoring order.
+            List<XAttribute> extensionAttributes = new List<XAttribute>();
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    bool allowed = true;
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Vital":
+                            vital = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Transaction":
+                            transaction = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            allowed = false;
+                            break;
+                    }
+
+                    if (!allowed)
+                    {
+                        this.core.UnexpectedAttribute(node, attrib);
+                    }
+                }
+                else
+                {
+                    // Save the extension attributes for later...
+                    extensionAttributes.Add(attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                if (!String.IsNullOrEmpty(previousId))
+                {
+                    id = this.core.CreateIdentifier("rba", previousId);
+                }
+
+                if (null == id)
+                {
+                    this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+                    id = Identifier.Invalid;
+                }
+                else if (!Common.IsIdentifier(id.Id))
+                {
+                    this.core.OnMessage(WixErrors.IllegalIdentifier(sourceLineNumbers, node.Name.LocalName, "Id", id.Id));
+                }
+            }
+
+            // Now that the rollback identifier is known, we can parse the extension attributes...
+            Dictionary<string, string> contextValues = new Dictionary<string, string>();
+            contextValues["RollbackBoundaryId"] = id.Id;
+            foreach (XAttribute attribute in extensionAttributes)
+            {
+                this.core.ParseExtensionAttribute(node, attribute, contextValues);
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                this.CreateRollbackBoundary(sourceLineNumbers, id, vital, transaction, parentType, parentId, previousType, previousId);
+            }
+
+            return id.Id;
+        }
+
+        /// <summary>
+        /// Parses one of the ChainPackage elements
+        /// </summary>
+        /// <param name="node">Element to parse</param>
+        /// <param name="packageType">Type of package to parse</param>
+        /// <param name="parentType">Type of parent group, if known.</param>
+        /// <param name="parentId">Identifier of parent group, if known.</param>
+        /// <param name="previousType">Type of previous item, if known.</param>
+        /// <param name="previousId">Identifier of previous item, if known</param>
+        /// <returns>Identifier for package element.</returns>
+        /// <remarks>This method contains the shared logic for parsing all of the ChainPackage
+        /// types, as there is more in common between them than different.</remarks>
+        private string ParseChainPackage(XElement node, WixBundlePackageType packageType, ComplexReferenceParentType parentType, string parentId, ComplexReferenceChildType previousType, string previousId)
+        {
+            Debug.Assert(ComplexReferenceParentType.PackageGroup == parentType);
+            Debug.Assert(ComplexReferenceChildType.Unknown == previousType || ComplexReferenceChildType.PackageGroup == previousType || ComplexReferenceChildType.Package == previousType);
+
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            string name = null;
+            string sourceFile = null;
+            string downloadUrl = null;
+            string after = null;
+            string installCondition = null;
+            YesNoAlwaysType cache = YesNoAlwaysType.Yes; // the default is to cache everything in tradeoff for stability over disk space.
+            string cacheId = null;
+            string description = null;
+            string displayName = null;
+            string logPathVariable = (packageType == WixBundlePackageType.Msu) ? String.Empty : null;
+            string rollbackPathVariable = (packageType == WixBundlePackageType.Msu) ? String.Empty : null;
+            YesNoType permanent = YesNoType.NotSet;
+            YesNoType visible = YesNoType.NotSet;
+            YesNoType vital = YesNoType.Yes;
+            string installCommand = null;
+            string repairCommand = null;
+            YesNoType repairable = YesNoType.NotSet;
+            string uninstallCommand = null;
+            YesNoDefaultType perMachine = YesNoDefaultType.NotSet;
+            string detectCondition = null;
+            string protocol = null;
+            int installSize = CompilerConstants.IntegerNotSet;
+            string msuKB = null;
+            YesNoType suppressLooseFilePayloadGeneration = YesNoType.NotSet;
+            YesNoType enableSignatureVerification = YesNoType.No;
+            YesNoDefaultType compressed = YesNoDefaultType.Default;
+            YesNoType displayInternalUI = YesNoType.NotSet;
+            YesNoType enableFeatureSelection = YesNoType.NotSet;
+            YesNoType forcePerMachine = YesNoType.NotSet;
+            Wix.RemotePayload remotePayload = null;
+            YesNoType slipstream = YesNoType.NotSet;
+
+            string[] expectedNetFx4Args = new string[] { "/q", "/norestart", "/chainingpackage" };
+
+            // This list lets us evaluate extension attributes *after* all core attributes
+            // have been parsed and dealt with, regardless of authoring order.
+            List<XAttribute> extensionAttributes = new List<XAttribute>();
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    bool allowed = true;
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Name":
+                            name = this.core.GetAttributeLongFilename(sourceLineNumbers, attrib, false, true);
+                            if (!this.core.IsValidLongFilename(name, false, true))
+                            {
+                                this.core.OnMessage(WixErrors.IllegalLongFilename(sourceLineNumbers, node.Name.LocalName, "Name", name));
+                            }
+                            break;
+                        case "SourceFile":
+                            sourceFile = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "DownloadUrl":
+                            downloadUrl = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "After":
+                            after = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "InstallCondition":
+                            installCondition = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Cache":
+                            cache = this.core.GetAttributeYesNoAlwaysValue(sourceLineNumbers, attrib);
+                            break;
+                        case "CacheId":
+                            cacheId = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Description":
+                            description = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "DisplayName":
+                            displayName = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "DisplayInternalUI":
+                            displayInternalUI = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            allowed = (packageType == WixBundlePackageType.Msi || packageType == WixBundlePackageType.Msp);
+                            break;
+                        case "EnableFeatureSelection":
+                            enableFeatureSelection = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            allowed = (packageType == WixBundlePackageType.Msi);
+                            break;
+                        case "ForcePerMachine":
+                            forcePerMachine = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            allowed = (packageType == WixBundlePackageType.Msi);
+                            break;
+                        case "LogPathVariable":
+                            logPathVariable = this.core.GetAttributeValue(sourceLineNumbers, attrib, EmptyRule.CanBeEmpty);
+                            break;
+                        case "RollbackLogPathVariable":
+                            rollbackPathVariable = this.core.GetAttributeValue(sourceLineNumbers, attrib, EmptyRule.CanBeEmpty);
+                            break;
+                        case "Permanent":
+                            permanent = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Visible":
+                            visible = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            allowed = (packageType == WixBundlePackageType.Msi);
+                            break;
+                        case "Vital":
+                            vital = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "InstallCommand":
+                            installCommand = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            allowed = (packageType == WixBundlePackageType.Exe);
+                            break;
+                        case "RepairCommand":
+                            repairCommand = this.core.GetAttributeValue(sourceLineNumbers, attrib, EmptyRule.CanBeEmpty);
+                            repairable = YesNoType.Yes;
+                            allowed = (packageType == WixBundlePackageType.Exe);
+                            break;
+                        case "UninstallCommand":
+                            uninstallCommand = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            allowed = (packageType == WixBundlePackageType.Exe);
+                            break;
+                        case "PerMachine":
+                            perMachine = this.core.GetAttributeYesNoDefaultValue(sourceLineNumbers, attrib);
+                            allowed = (packageType == WixBundlePackageType.Exe || packageType == WixBundlePackageType.Msp);
+                            break;
+                        case "DetectCondition":
+                            detectCondition = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            allowed = (packageType == WixBundlePackageType.Exe || packageType == WixBundlePackageType.Msu);
+                            break;
+                        case "Protocol":
+                            protocol = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            allowed = (packageType == WixBundlePackageType.Exe);
+                            break;
+                        case "InstallSize":
+                            installSize = this.core.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, int.MaxValue);
+                            break;
+                        case "KB":
+                            msuKB = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            allowed = (packageType == WixBundlePackageType.Msu);
+                            break;
+                        case "Compressed":
+                            compressed = this.core.GetAttributeYesNoDefaultValue(sourceLineNumbers, attrib);
+                            break;
+                        case "SuppressLooseFilePayloadGeneration":
+                            this.core.OnMessage(WixWarnings.DeprecatedAttribute(sourceLineNumbers, node.Name.LocalName, attrib.Name.LocalName));
+                            suppressLooseFilePayloadGeneration = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            allowed = (packageType == WixBundlePackageType.Msi);
+                            break;
+                        case "EnableSignatureVerification":
+                            enableSignatureVerification = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Slipstream":
+                            slipstream = this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            allowed = (packageType == WixBundlePackageType.Msp);
+                            break;
+                        default:
+                            allowed = false;
+                            break;
+                    }
+
+                    if (!allowed)
+                    {
+                        this.core.UnexpectedAttribute(node, attrib);
+                    }
+                }
+                else
+                {
+                    // Save the extension attributes for later...
+                    extensionAttributes.Add(attrib);
+                }
+            }
+
+            // We need to handle RemotePayload up front because it effects value of sourceFile which is used in Id generation.  Id is needed by other child elements.
+            foreach (XElement child in node.Elements(CompilerCore.WixNamespace + "RemotePayload"))
+            {
+                SourceLineNumber childSourceLineNumbers = Preprocessor.GetSourceLineNumbers(child);
+
+                if (CompilerCore.WixNamespace == node.Name.Namespace && node.Name.LocalName != "ExePackage" && node.Name.LocalName != "MsuPackage")
+                {
+                    this.core.OnMessage(WixErrors.RemotePayloadUnsupported(childSourceLineNumbers));
+                    continue;
+                }
+
+                if (null != remotePayload)
+                {
+                    this.core.OnMessage(WixErrors.TooManyChildren(childSourceLineNumbers, node.Name.LocalName, child.Name.LocalName));
+                }
+
+                remotePayload = this.ParseRemotePayloadElement(child);
+            }
+
+            if (String.IsNullOrEmpty(sourceFile))
+            {
+                if (String.IsNullOrEmpty(name))
+                {
+                    this.core.OnMessage(WixErrors.ExpectedAttributesWithOtherAttribute(sourceLineNumbers, node.Name.LocalName, "Name", "SourceFile"));
+                }
+                else if (null == remotePayload)
+                {
+                    sourceFile = Path.Combine("SourceDir", name);
+                }
+                else
+                {
+                    sourceFile = String.Empty;  // SourceFile is required it cannot be null.
+                }
+            }
+            else if (null != remotePayload)
+            {
+                this.core.OnMessage(WixErrors.UnexpectedElementWithAttribute(sourceLineNumbers, node.Name.LocalName, "RemotePayload", "SourceFile"));
+            }
+            else if (sourceFile.EndsWith(Path.DirectorySeparatorChar.ToString(), StringComparison.Ordinal))
+            {
+                if (String.IsNullOrEmpty(name))
+                {
+                    this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Name", "SourceFile", sourceFile));
+                }
+                else
+                {
+                    sourceFile = Path.Combine(sourceFile, Path.GetFileName(name));
+                }
+            }
+
+            if (null == downloadUrl && null != remotePayload)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttributeWithElement(sourceLineNumbers, node.Name.LocalName, "DownloadUrl", "RemotePayload"));
+            }
+
+            if (YesNoDefaultType.No != compressed && null != remotePayload)
+            {
+                compressed = YesNoDefaultType.No;
+                this.core.OnMessage(WixWarnings.RemotePayloadsMustNotAlsoBeCompressed(sourceLineNumbers, node.Name.LocalName));
+            }
+
+            if (null == id)
+            {
+                if (!String.IsNullOrEmpty(name))
+                {
+                    id = this.core.CreateIdentifierFromFilename(Path.GetFileName(name));
+                }
+                else if (!String.IsNullOrEmpty(sourceFile))
+                {
+                    id = this.core.CreateIdentifierFromFilename(Path.GetFileName(sourceFile));
+                }
+
+                if (null == id)
+                {
+                    this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+                    id = Identifier.Invalid;
+                }
+                else if (!Common.IsIdentifier(id.Id))
+                {
+                    this.core.OnMessage(WixErrors.IllegalIdentifier(sourceLineNumbers, node.Name.LocalName, "Id", id.Id));
+                }
+            }
+
+            if (null == logPathVariable)
+            {
+                logPathVariable = String.Concat("WixBundleLog_", id.Id);
+            }
+
+            if (null == rollbackPathVariable)
+            {
+                rollbackPathVariable = String.Concat("WixBundleRollbackLog_", id.Id);
+            }
+
+            if (!String.IsNullOrEmpty(protocol) && !protocol.Equals("burn", StringComparison.Ordinal) && !protocol.Equals("netfx4", StringComparison.Ordinal) && !protocol.Equals("none", StringComparison.Ordinal))
+            {
+                this.core.OnMessage(WixErrors.IllegalAttributeValueWithLegalList(sourceLineNumbers, node.Name.LocalName, "Protocol", protocol, "none, burn, netfx4"));
+            }
+
+            if (!String.IsNullOrEmpty(protocol) && protocol.Equals("netfx4", StringComparison.Ordinal))
+            {
+                foreach (string expectedArgument in expectedNetFx4Args)
+                {
+                    if (null == installCommand || -1 == installCommand.IndexOf(expectedArgument, StringComparison.OrdinalIgnoreCase))
+                    {
+                        this.core.OnMessage(WixWarnings.AttributeShouldContain(sourceLineNumbers, node.Name.LocalName, "InstallCommand", installCommand, expectedArgument, "Protocol", "netfx4"));
+                    }
+
+                    if (null == repairCommand || -1 == repairCommand.IndexOf(expectedArgument, StringComparison.OrdinalIgnoreCase))
+                    {
+                        this.core.OnMessage(WixWarnings.AttributeShouldContain(sourceLineNumbers, node.Name.LocalName, "RepairCommand", repairCommand, expectedArgument, "Protocol", "netfx4"));
+                    }
+
+                    if (null == uninstallCommand || -1 == uninstallCommand.IndexOf(expectedArgument, StringComparison.OrdinalIgnoreCase))
+                    {
+                        this.core.OnMessage(WixWarnings.AttributeShouldContain(sourceLineNumbers, node.Name.LocalName, "UninstallCommand", uninstallCommand, expectedArgument, "Protocol", "netfx4"));
+                    }
+                }
+            }
+
+            // Only set default scope for EXEs and MSPs if not already set.
+            if ((WixBundlePackageType.Exe == packageType || WixBundlePackageType.Msp == packageType) && YesNoDefaultType.NotSet == perMachine)
+            {
+                perMachine = YesNoDefaultType.Default;
+            }
+
+            // Now that the package ID is known, we can parse the extension attributes...
+            Dictionary<string, string> contextValues = new Dictionary<string, string>() { { "PackageId", id.Id } };
+            foreach (XAttribute attribute in extensionAttributes)
+            {
+                this.core.ParseExtensionAttribute(node, attribute, contextValues);
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    bool allowed = true;
+                    switch (child.Name.LocalName)
+                    {
+                        case "SlipstreamMsp":
+                            allowed = (packageType == WixBundlePackageType.Msi);
+                            if (allowed)
+                            {
+                                this.ParseSlipstreamMspElement(child, id.Id);
+                            }
+                            break;
+                        case "MsiProperty":
+                            allowed = (packageType == WixBundlePackageType.Msi || packageType == WixBundlePackageType.Msp);
+                            if (allowed)
+                            {
+                                this.ParseMsiPropertyElement(child, id.Id);
+                            }
+                            break;
+                        case "Payload":
+                            this.ParsePayloadElement(child, ComplexReferenceParentType.Package, id.Id, ComplexReferenceChildType.Unknown, null);
+                            break;
+                        case "PayloadGroupRef":
+                            this.ParsePayloadGroupRefElement(child, ComplexReferenceParentType.Package, id.Id, ComplexReferenceChildType.Unknown, null);
+                            break;
+                        case "ExitCode":
+                            allowed = (packageType == WixBundlePackageType.Exe);
+                            if (allowed)
+                            {
+                                this.ParseExitCodeElement(child, id.Id);
+                            }
+                            break;
+                        case "CommandLine":
+                            allowed = (packageType == WixBundlePackageType.Exe);
+                            if (allowed)
+                            {
+                                this.ParseCommandLineElement(child, id.Id);
+                            }
+                            break;
+                        case "RemotePayload":
+                            // Handled previously
+                            break;
+                        default:
+                            allowed = false;
+                            break;
+                    }
+
+                    if (!allowed)
+                    {
+                        this.core.UnexpectedElement(node, child);
+                    }
+                }
+                else
+                {
+                    Dictionary<string, string> context = new Dictionary<string, string>() { { "Id", id.Id } };
+                    this.core.ParseExtensionElement(node, child, context);
+                }
+            }
+
+            if (!this.core.EncounteredError)
+            {
+                // We create the package contents as a payload with this package as the parent
+                this.CreatePayloadRow(sourceLineNumbers, id, name, sourceFile, downloadUrl, ComplexReferenceParentType.Package, id.Id,
+                    ComplexReferenceChildType.Unknown, null, compressed, enableSignatureVerification, displayName, description, remotePayload);
+
+                WixChainItemRow chainItemRow = (WixChainItemRow)this.core.CreateRow(sourceLineNumbers, "WixChainItem", id);
+
+                WixBundlePackageAttributes attributes = 0;
+                attributes |= (YesNoType.Yes == permanent) ? WixBundlePackageAttributes.Permanent : 0;
+                attributes |= (YesNoType.Yes == visible) ? WixBundlePackageAttributes.Visible : 0;
+
+                WixBundlePackageRow chainPackageRow = (WixBundlePackageRow)this.core.CreateRow(sourceLineNumbers, "WixBundlePackage", id);
+                chainPackageRow.Type = packageType;
+                chainPackageRow.PackagePayload = id.Id;
+                chainPackageRow.Attributes = attributes;
+
+                chainPackageRow.InstallCondition = installCondition;
+
+                if (YesNoAlwaysType.NotSet != cache)
+                {
+                    chainPackageRow.Cache = cache;
+                }
+
+                chainPackageRow.CacheId = cacheId;
+
+                if (YesNoType.NotSet != vital)
+                {
+                    chainPackageRow.Vital = vital;
+                }
+
+                if (YesNoDefaultType.NotSet != perMachine)
+                {
+                    chainPackageRow.PerMachine = perMachine;
+                }
+
+                chainPackageRow.LogPathVariable = logPathVariable;
+                chainPackageRow.RollbackLogPathVariable = rollbackPathVariable;
+
+                if (CompilerConstants.IntegerNotSet != installSize)
+                {
+                    chainPackageRow.InstallSize = installSize;
+                }
+
+                switch (packageType)
+                {
+                    case WixBundlePackageType.Exe:
+                        WixBundleExePackageAttributes exeAttributes = 0;
+                        exeAttributes |= (YesNoType.Yes == repairable) ? WixBundleExePackageAttributes.Repairable : 0;
+
+                        WixBundleExePackageRow exeRow = (WixBundleExePackageRow)this.core.CreateRow(sourceLineNumbers, "WixBundleExePackage", id);
+                        exeRow.Attributes = exeAttributes;
+                        exeRow.DetectCondition = detectCondition;
+                        exeRow.InstallCommand = installCommand;
+                        exeRow.RepairCommand = repairCommand;
+                        exeRow.UninstallCommand = uninstallCommand;
+                        exeRow.ExeProtocol = protocol;
+                        break;
+
+                    case WixBundlePackageType.Msi:
+                        WixBundleMsiPackageAttributes msiAttributes = 0;
+                        msiAttributes |= (YesNoType.Yes == displayInternalUI) ? WixBundleMsiPackageAttributes.DisplayInternalUI : 0;
+                        msiAttributes |= (YesNoType.Yes == enableFeatureSelection) ? WixBundleMsiPackageAttributes.EnableFeatureSelection : 0;
+                        msiAttributes |= (YesNoType.Yes == forcePerMachine) ? WixBundleMsiPackageAttributes.ForcePerMachine : 0;
+                        msiAttributes |= (YesNoType.Yes == suppressLooseFilePayloadGeneration) ? WixBundleMsiPackageAttributes.SuppressLooseFilePayloadGeneration : 0;
+
+                        WixBundleMsiPackageRow msiRow = (WixBundleMsiPackageRow)this.core.CreateRow(sourceLineNumbers, "WixBundleMsiPackage", id);
+                        msiRow.Attributes = msiAttributes;
+                        break;
+
+                    case WixBundlePackageType.Msp:
+                        WixBundleMspPackageAttributes mspAttributes = 0;
+                        mspAttributes |= (YesNoType.Yes == displayInternalUI) ? WixBundleMspPackageAttributes.DisplayInternalUI : 0;
+                        mspAttributes |= (YesNoType.Yes == slipstream) ? WixBundleMspPackageAttributes.Slipstream : 0;
+
+                        WixBundleMspPackageRow mspRow = (WixBundleMspPackageRow)this.core.CreateRow(sourceLineNumbers, "WixBundleMspPackage", id);
+                        mspRow.Attributes = mspAttributes;
+                        break;
+
+                    case WixBundlePackageType.Msu:
+                        WixBundleMsuPackageRow msuRow = (WixBundleMsuPackageRow)this.core.CreateRow(sourceLineNumbers, "WixBundleMsuPackage", id);
+                        msuRow.DetectCondition = detectCondition;
+                        msuRow.MsuKB = msuKB;
+                        break;
+                }
+
+                this.CreateChainPackageMetaRows(sourceLineNumbers, parentType, parentId, ComplexReferenceChildType.Package, id.Id, previousType, previousId, after);
+            }
+
+            return id.Id;
+        }
+
+        /// <summary>
+        /// Parse CommandLine element.
+        /// </summary>
+        /// <param name="node">Element to parse</param>
+        private void ParseCommandLineElement(XElement node, string packageId)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string installArgument = null;
+            string uninstallArgument = null;
+            string repairArgument = null;
+            string condition = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "InstallArgument":
+                            installArgument = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "UninstallArgument":
+                            uninstallArgument = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "RepairArgument":
+                            repairArgument = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Condition":
+                            condition = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (String.IsNullOrEmpty(condition))
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Condition"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                WixBundlePackageCommandLineRow row = (WixBundlePackageCommandLineRow)this.core.CreateRow(sourceLineNumbers, "WixBundlePackageCommandLine");
+                row.ChainPackageId = packageId;
+                row.InstallArgument = installArgument;
+                row.UninstallArgument = uninstallArgument;
+                row.RepairArgument = repairArgument;
+                row.Condition = condition;
+            }
+        }
+
+        /// <summary>
+        /// Parse PackageGroup element.
+        /// </summary>
+        /// <param name="node">Element to parse</param>
+        private void ParsePackageGroupElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+                id = Identifier.Invalid;
+            }
+
+            ComplexReferenceChildType previousType = ComplexReferenceChildType.Unknown;
+            string previousId = null;
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "MsiPackage":
+                            previousId = this.ParseMsiPackageElement(child, ComplexReferenceParentType.PackageGroup, id.Id, previousType, previousId);
+                            previousType = ComplexReferenceChildType.Package;
+                            break;
+                        case "MspPackage":
+                            previousId = this.ParseMspPackageElement(child, ComplexReferenceParentType.PackageGroup, id.Id, previousType, previousId);
+                            previousType = ComplexReferenceChildType.Package;
+                            break;
+                        case "MsuPackage":
+                            previousId = this.ParseMsuPackageElement(child, ComplexReferenceParentType.PackageGroup, id.Id, previousType, previousId);
+                            previousType = ComplexReferenceChildType.Package;
+                            break;
+                        case "ExePackage":
+                            previousId = this.ParseExePackageElement(child, ComplexReferenceParentType.PackageGroup, id.Id, previousType, previousId);
+                            previousType = ComplexReferenceChildType.Package;
+                            break;
+                        case "RollbackBoundary":
+                            previousId = this.ParseRollbackBoundaryElement(child, ComplexReferenceParentType.PackageGroup, id.Id, previousType, previousId);
+                            previousType = ComplexReferenceChildType.Package;
+                            break;
+                        case "PackageGroupRef":
+                            previousId = this.ParsePackageGroupRefElement(child, ComplexReferenceParentType.PackageGroup, id.Id, previousType, previousId);
+                            previousType = ComplexReferenceChildType.PackageGroup;
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+
+
+            if (!this.core.EncounteredError)
+            {
+                this.core.CreateRow(sourceLineNumbers, "WixBundlePackageGroup", id);
+            }
+        }
+
+        /// <summary>
+        /// Parses a package group reference element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="parentType">ComplexReferenceParentType of parent element (Unknown or PackageGroup).</param>
+        /// <param name="parentId">Identifier of parent element.</param>
+        /// <returns>Identifier for package group element.</rereturns>
+        private string ParsePackageGroupRefElement(XElement node, ComplexReferenceParentType parentType, string parentId)
+        {
+            return this.ParsePackageGroupRefElement(node, parentType, parentId, ComplexReferenceChildType.Unknown, null);
+        }
+
+        /// <summary>
+        /// Parses a package group reference element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="parentType">ComplexReferenceParentType of parent element (Unknown or PackageGroup).</param>
+        /// <param name="parentId">Identifier of parent element.</param>
+        /// <param name="parentType">ComplexReferenceParentType of previous element (Unknown, Package, or PackageGroup).</param>
+        /// <param name="parentId">Identifier of parent element.</param>
+        /// <returns>Identifier for package group element.</rereturns>
+        private string ParsePackageGroupRefElement(XElement node, ComplexReferenceParentType parentType, string parentId, ComplexReferenceChildType previousType, string previousId)
+        {
+            Debug.Assert(ComplexReferenceParentType.Unknown == parentType || ComplexReferenceParentType.PackageGroup == parentType || ComplexReferenceParentType.Container == parentType);
+            Debug.Assert(ComplexReferenceChildType.Unknown == previousType || ComplexReferenceChildType.PackageGroup == previousType || ComplexReferenceChildType.Package == previousType);
+
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string id = null;
+            string after = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.core.CreateSimpleReference(sourceLineNumbers, "WixBundlePackageGroup", id);
+                            break;
+                        case "After":
+                            after = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            if (null != after && ComplexReferenceParentType.Container == parentType)
+            {
+                this.core.OnMessage(WixErrors.IllegalAttributeWhenNested(sourceLineNumbers, node.Name.LocalName, "After", parentId));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (ComplexReferenceParentType.Container == parentType)
+            {
+                this.core.CreateWixGroupRow(sourceLineNumbers, ComplexReferenceParentType.Container, parentId, ComplexReferenceChildType.PackageGroup, id);
+            }
+            else
+            {
+                this.CreateChainPackageMetaRows(sourceLineNumbers, parentType, parentId, ComplexReferenceChildType.PackageGroup, id, previousType, previousId, after);
+            }
+
+            return id;
+        }
+
+        /// <summary>
+        /// Creates rollback boundary.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line numbers.</param>
+        /// <param name="id">Identifier for the rollback boundary.</param>
+        /// <param name="vital">Indicates whether the rollback boundary is vital or not.</param>
+        /// <param name="parentType">Type of parent group.</param>
+        /// <param name="parentId">Identifier of parent group.</param>
+        /// <param name="previousType">Type of previous item, if any.</param>
+        /// <param name="previousId">Identifier of previous item, if any.</param>
+        private void CreateRollbackBoundary(SourceLineNumber sourceLineNumbers, Identifier id, YesNoType vital, YesNoType transaction, ComplexReferenceParentType parentType, string parentId, ComplexReferenceChildType previousType, string previousId)
+        {
+            WixChainItemRow row = (WixChainItemRow)this.core.CreateRow(sourceLineNumbers, "WixChainItem", id);
+
+            WixBundleRollbackBoundaryRow rollbackBoundary = (WixBundleRollbackBoundaryRow)this.core.CreateRow(sourceLineNumbers, "WixBundleRollbackBoundary", id);
+
+            if (YesNoType.NotSet != vital)
+            {
+                rollbackBoundary.Vital = vital;
+            }
+            if (YesNoType.NotSet != transaction)
+            {
+                rollbackBoundary.Transaction = transaction;
+            }
+
+            this.CreateChainPackageMetaRows(sourceLineNumbers, parentType, parentId, ComplexReferenceChildType.Package, id.Id, previousType, previousId, null);
+        }
+
+        /// <summary>
+        /// Creates group and ordering information for packages
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line numbers.</param>
+        /// <param name="parentType">Type of parent group, if known.</param>
+        /// <param name="parentId">Identifier of parent group, if known.</param>
+        /// <param name="type">Type of this item.</param>
+        /// <param name="id">Identifier for this item.</param>
+        /// <param name="previousType">Type of previous item, if known.</param>
+        /// <param name="previousId">Identifier of previous item, if known</param>
+        /// <param name="afterId">Identifier of explicit 'After' attribute, if given.</param>
+        private void CreateChainPackageMetaRows(SourceLineNumber sourceLineNumbers,
+            ComplexReferenceParentType parentType, string parentId,
+            ComplexReferenceChildType type, string id,
+            ComplexReferenceChildType previousType, string previousId, string afterId)
+        {
+            // If there's an explicit 'After' attribute, it overrides the inferred previous item.
+            if (null != afterId)
+            {
+                previousType = ComplexReferenceChildType.Package;
+                previousId = afterId;
+            }
+
+            this.CreateGroupAndOrderingRows(sourceLineNumbers, parentType, parentId, type, id, previousType, previousId);
+        }
+
+        // TODO: Should we define our own enum for this, just to ensure there's no "cross-contamination"?
+        // TODO: Also, we could potentially include an 'Attributes' field to track things like
+        // 'before' vs. 'after', and explicit vs. inferred dependencies.
+        private void CreateWixOrderingRow(SourceLineNumber sourceLineNumbers,
+            ComplexReferenceChildType itemType, string itemId,
+            ComplexReferenceChildType dependsOnType, string dependsOnId)
+        {
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "WixOrdering");
+                row[0] = itemType.ToString();
+                row[1] = itemId;
+                row[2] = dependsOnType.ToString();
+                row[3] = dependsOnId;
+            }
+        }
+
+        /// <summary>
+        /// Parse MsiProperty element
+        /// </summary>
+        /// <param name="node">Element to parse</param>
+        /// <param name="packageId">Id of parent element</param>
+        private void ParseMsiPropertyElement(XElement node, string packageId)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string name = null;
+            string value = null;
+            string condition = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Name":
+                            name = this.core.GetAttributeMsiPropertyNameValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Value":
+                            value = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Condition":
+                            condition = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == name)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Name"));
+            }
+
+            if (null == value)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Value"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                WixBundleMsiPropertyRow row = (WixBundleMsiPropertyRow)this.core.CreateRow(sourceLineNumbers, "WixBundleMsiProperty");
+                row.ChainPackageId = packageId;
+                row.Name = name;
+                row.Value = value;
+
+                if (!String.IsNullOrEmpty(condition))
+                {
+                    row.Condition = condition;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parse SlipstreamMsp element
+        /// </summary>
+        /// <param name="node">Element to parse</param>
+        /// <param name="packageId">Id of parent element</param>
+        private void ParseSlipstreamMspElement(XElement node, string packageId)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string id = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.core.CreateSimpleReference(sourceLineNumbers, "WixBundlePackage", id);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                WixBundleSlipstreamMspRow row = (WixBundleSlipstreamMspRow)this.core.CreateRow(sourceLineNumbers, "WixBundleSlipstreamMsp");
+                row.ChainPackageId = packageId;
+                row.MspPackageId = id;
+            }
+        }
+
+        /// <summary>
+        /// Parse RelatedBundle element
+        /// </summary>
+        /// <param name="node">Element to parse</param>
+        private void ParseRelatedBundleElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string id = null;
+            string action = null;
+            Wix.RelatedBundle.ActionType actionType = Wix.RelatedBundle.ActionType.Detect;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeGuidValue(sourceLineNumbers, attrib, false);
+                            break;
+                        case "Action":
+                            action = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            if (!String.IsNullOrEmpty(action))
+            {
+                actionType = Wix.RelatedBundle.ParseActionType(action);
+                switch (actionType)
+                {
+                    case Wix.RelatedBundle.ActionType.Detect:
+                        break;
+                    case Wix.RelatedBundle.ActionType.Upgrade:
+                        break;
+                    case Wix.RelatedBundle.ActionType.Addon:
+                        break;
+                    case Wix.RelatedBundle.ActionType.Patch:
+                        break;
+                    default:
+                        this.core.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, node.Name.LocalName, "Action", action, "Detect", "Upgrade", "Addon", "Patch"));
+                        break;
+                }
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "WixRelatedBundle");
+                row[0] = id;
+                row[1] = (int)actionType;
+            }
+        }
+
+        /// <summary>
+        /// Parse Update element
+        /// </summary>
+        /// <param name="node">Element to parse</param>
+        private void ParseUpdateElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string location = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Location":
+                            location = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == location)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Location"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                Row row = this.core.CreateRow(sourceLineNumbers, "WixBundleUpdate");
+                row[0] = location;
+            }
+        }
+
+        /// <summary>
+        /// Parse Variable element
+        /// </summary>
+        /// <param name="node">Element to parse</param>
+        private void ParseVariableElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            bool hidden = false;
+            string name = null;
+            bool persisted = false;
+            string value = null;
+            string type = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Hidden":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                hidden = true;
+                            }
+                            break;
+                        case "Name":
+                            name = this.core.GetAttributeBundleVariableValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Persisted":
+                            if (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                persisted = true;
+                            }
+                            break;
+                        case "Value":
+                            value = this.core.GetAttributeValue(sourceLineNumbers, attrib, EmptyRule.CanBeEmpty);
+                            break;
+                        case "Type":
+                            type = this.core.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == name)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Name"));
+            }
+            else if (name.StartsWith("Wix", StringComparison.OrdinalIgnoreCase))
+            {
+                this.core.OnMessage(WixErrors.ReservedNamespaceViolation(sourceLineNumbers, node.Name.LocalName, "Name", "Wix"));
+            }
+
+            if (null == type && null != value)
+            {
+                // Infer the type from the current value... 
+                if (value.StartsWith("v", StringComparison.OrdinalIgnoreCase))
+                {
+                    // Version constructor does not support simple "v#" syntax so check to see if the value is
+                    // non-negative real quick.
+                    Int32 number;
+                    if (Int32.TryParse(value.Substring(1), NumberStyles.None, CultureInfo.InvariantCulture.NumberFormat, out number))
+                    {
+                        type = "version";
+                    }
+                    else
+                    {
+                        // Sadly, Version doesn't have a TryParse() method until .NET 4, so we have to try/catch to see if it parses.
+                        try
+                        {
+                            Version version = new Version(value.Substring(1));
+                            type = "version";
+                        }
+                        catch (Exception)
+                        {
+                        }
+                    }
+                }
+
+                // Not a version, check for numeric.
+                if (null == type)
+                {
+                    Int64 number;
+                    if (Int64.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture.NumberFormat, out number))
+                    {
+                        type = "numeric";
+                    }
+                    else
+                    {
+                        type = "string";
+                    }
+                }
+            }
+
+            if (null == value && null != type)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, "Variable", "Value", "Type"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                WixBundleVariableRow row = (WixBundleVariableRow)this.core.CreateRow(sourceLineNumbers, "WixBundleVariable");
+                row.Id = name;
+                row.Value = value;
+                row.Type = type;
+                row.Hidden = hidden;
+                row.Persisted = persisted;
+            }
+        }
+
+
+
+        /// <summary>
+        /// Parses a Wix element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        private void ParseWixElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            string requiredVersion = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "RequiredVersion":
+                            requiredVersion = this.core.GetAttributeVersionValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null != requiredVersion)
+            {
+                this.core.VerifyRequiredVersion(sourceLineNumbers, requiredVersion);
+            }
+
+            foreach (XElement child in node.Elements())
+            {
+                if (CompilerCore.WixNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "Bundle":
+                            this.ParseBundleElement(child);
+                            break;
+                        case "Fragment":
+                            this.ParseFragmentElement(child);
+                            break;
+                        case "Module":
+                            this.ParseModuleElement(child);
+                            break;
+                        case "PatchCreation":
+                            this.ParsePatchCreationElement(child);
+                            break;
+                        case "Product":
+                            this.ParseProductElement(child);
+                            break;
+                        case "Patch":
+                            this.ParsePatchElement(child);
+                            break;
+                        default:
+                            this.core.UnexpectedElement(node, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionElement(node, child);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses a WixVariable element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        private void ParseWixVariableElement(XElement node)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(node);
+            Identifier id = null;
+            bool overridable = false;
+            string value = null;
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || CompilerCore.WixNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.core.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Overridable":
+                            overridable = (YesNoType.Yes == this.core.GetAttributeYesNoValue(sourceLineNumbers, attrib));
+                            break;
+                        case "Value":
+                            value = this.core.GetAttributeValue(sourceLineNumbers, attrib, EmptyRule.CanBeEmpty);
+                            break;
+                        default:
+                            this.core.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.core.ParseExtensionAttribute(node, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Id"));
+            }
+
+            if (null == value)
+            {
+                this.core.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Value"));
+            }
+
+            this.core.ParseForExtensionElements(node);
+
+            if (!this.core.EncounteredError)
+            {
+                WixVariableRow wixVariableRow = (WixVariableRow)this.core.CreateRow(sourceLineNumbers, "WixVariable", id);
+                wixVariableRow.Value = value;
+                wixVariableRow.Overridable = overridable;
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/CompilerCore.cs b/src/WixToolset.Core/CompilerCore.cs
new file mode 100644
index 00000000..8640a2da
--- /dev/null
+++ b/src/WixToolset.Core/CompilerCore.cs
@@ -0,0 +1,1932 @@
+// 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
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Globalization;
+    using System.IO;
+    using System.Reflection;
+    using System.Security.Cryptography;
+    using System.Text;
+    using System.Text.RegularExpressions;
+    using System.Xml.Linq;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+    using WixToolset.Extensibility;
+    using Wix = WixToolset.Data.Serialize;
+
+    internal enum ValueListKind
+    {
+        /// <summary>
+        /// A list of values with nothing before the final value.
+        /// </summary>
+        None,
+
+        /// <summary>
+        /// A list of values with 'and' before the final value.
+        /// </summary>
+        And,
+
+        /// <summary>
+        /// A list of values with 'or' before the final value.
+        /// </summary>
+        Or
+    }
+
+    /// <summary>
+    /// Core class for the compiler.
+    /// </summary>
+    internal sealed class CompilerCore : ICompilerCore
+    {
+        internal static readonly XNamespace W3SchemaPrefix = "http://www.w3.org/";
+        internal static readonly XNamespace WixNamespace = "http://wixtoolset.org/schemas/v4/wxs";
+
+        public const int DefaultMaximumUncompressedMediaSize = 200; // Default value is 200 MB
+        public const int MinValueOfMaxCabSizeForLargeFileSplitting = 20; // 20 MB
+        public const int MaxValueOfMaxCabSizeForLargeFileSplitting = 2 * 1024; // 2048 MB (i.e. 2 GB)
+
+        private static readonly Regex AmbiguousFilename = new Regex(@"^.{6}\~\d", RegexOptions.Compiled);
+
+        private const string IllegalLongFilenameCharacters = @"[\\\?|><:/\*""]"; // illegal: \ ? | > < : / * "
+        private static readonly Regex IllegalLongFilename = new Regex(IllegalLongFilenameCharacters, RegexOptions.Compiled);
+
+        private const string LegalLongFilenameCharacters = @"[^\\\?|><:/\*""]";  // opposite of illegal above.
+        private static readonly Regex LegalLongFilename = new Regex(String.Concat("^", LegalLongFilenameCharacters, @"{1,259}$"), RegexOptions.Compiled);
+
+        private const string LegalRelativeLongFilenameCharacters = @"[^\?|><:/\*""]"; // (like legal long, but we allow '\') illegal: ? | > < : / * "
+        private static readonly Regex LegalRelativeLongFilename = new Regex(String.Concat("^", LegalRelativeLongFilenameCharacters, @"{1,259}$"), RegexOptions.Compiled);
+
+        private const string LegalWildcardLongFilenameCharacters = @"[^\\|><:/""]"; // illegal: \ | > < : / "
+        private static readonly Regex LegalWildcardLongFilename = new Regex(String.Concat("^", LegalWildcardLongFilenameCharacters, @"{1,259}$"));
+
+        private static readonly Regex PutGuidHere = new Regex(@"PUT\-GUID\-(?:\d+\-)?HERE", RegexOptions.Singleline);
+
+        private static readonly Regex LegalIdentifierWithAccess = new Regex(@"^((?<access>public|internal|protected|private)\s+)?(?<id>[_A-Za-z][0-9A-Za-z_\.]*)$", RegexOptions.Compiled | RegexOptions.ExplicitCapture);
+
+        // Built-in variables (from burn\engine\variable.cpp, "vrgBuiltInVariables", around line 113)
+        private static readonly List<String> BuiltinBundleVariables = new List<string>(
+            new string[] {
+                "AdminToolsFolder",
+                "AppDataFolder",
+                "CommonAppDataFolder",
+                "CommonFiles64Folder",
+                "CommonFilesFolder",
+                "CompatibilityMode",
+                "Date",
+                "DesktopFolder",
+                "FavoritesFolder",
+                "FontsFolder",
+                "InstallerName",
+                "InstallerVersion",
+                "LocalAppDataFolder",
+                "LogonUser",
+                "MyPicturesFolder",
+                "NTProductType",
+                "NTSuiteBackOffice",
+                "NTSuiteDataCenter",
+                "NTSuiteEnterprise",
+                "NTSuitePersonal",
+                "NTSuiteSmallBusiness",
+                "NTSuiteSmallBusinessRestricted",
+                "NTSuiteWebServer",
+                "PersonalFolder",
+                "Privileged",
+                "ProgramFiles64Folder",
+                "ProgramFiles6432Folder",
+                "ProgramFilesFolder",
+                "ProgramMenuFolder",
+                "RebootPending",
+                "SendToFolder",
+                "ServicePackLevel",
+                "StartMenuFolder",
+                "StartupFolder",
+                "System64Folder",
+                "SystemFolder",
+                "TempFolder",
+                "TemplateFolder",
+                "TerminalServer",
+                "UserLanguageID",
+                "UserUILanguageID",
+                "VersionMsi",
+                "VersionNT",
+                "VersionNT64",
+                "WindowsFolder",
+                "WindowsVolume",
+                "WixBundleAction",
+                "WixBundleForcedRestartPackage",
+                "WixBundleElevated",
+                "WixBundleInstalled",
+                "WixBundleProviderKey",
+                "WixBundleTag",
+                "WixBundleVersion",
+            });
+
+        private static readonly List<string> DisallowedMsiProperties = new List<string>(
+            new string[] {
+                "ACTION",
+                "ADDLOCAL",
+                "ADDSOURCE",
+                "ADDDEFAULT",
+                "ADVERTISE",
+                "ALLUSERS",
+                "REBOOT",
+                "REINSTALL",
+                "REINSTALLMODE",
+                "REMOVE"
+            });
+
+        private TableDefinitionCollection tableDefinitions;
+        private Dictionary<XNamespace, ICompilerExtension> extensions;
+        private Intermediate intermediate;
+        private bool showPedanticMessages;
+
+        private HashSet<string> activeSectionInlinedDirectoryIds;
+        private HashSet<string> activeSectionSimpleReferences;
+
+        /// <summary>
+        /// Constructor for all compiler core.
+        /// </summary>
+        /// <param name="intermediate">The Intermediate object representing compiled source document.</param>
+        /// <param name="tableDefinitions">The loaded table definition collection.</param>
+        /// <param name="extensions">The WiX extensions collection.</param>
+        internal CompilerCore(Intermediate intermediate, TableDefinitionCollection tableDefinitions, Dictionary<XNamespace, ICompilerExtension> extensions)
+        {
+            this.tableDefinitions = tableDefinitions;
+            this.extensions = extensions;
+            this.intermediate = intermediate;
+        }
+
+        /// <summary>
+        /// Gets the section the compiler is currently emitting symbols into.
+        /// </summary>
+        /// <value>The section the compiler is currently emitting symbols into.</value>
+        public Section ActiveSection { get; private set; }
+
+        /// <summary>
+        /// Gets or sets the platform which the compiler will use when defaulting 64-bit attributes and elements.
+        /// </summary>
+        /// <value>The platform which the compiler will use when defaulting 64-bit attributes and elements.</value>
+        public Platform CurrentPlatform { get; set; }
+
+        /// <summary>
+        /// Gets whether the compiler core encountered an error while processing.
+        /// </summary>
+        /// <value>Flag if core encountered an error during processing.</value>
+        public bool EncounteredError
+        {
+            get { return Messaging.Instance.EncounteredError; }
+        }
+
+        /// <summary>
+        /// Gets or sets the option to show pedantic messages.
+        /// </summary>
+        /// <value>The option to show pedantic messages.</value>
+        public bool ShowPedanticMessages
+        {
+            get { return this.showPedanticMessages; }
+            set { this.showPedanticMessages = value; }
+        }
+
+        /// <summary>
+        /// Gets the table definitions used by the compiler core.
+        /// </summary>
+        /// <value>Table definition collection.</value>
+        public TableDefinitionCollection TableDefinitions
+        {
+            get { return this.tableDefinitions; }
+        }
+
+        /// <summary>
+        /// Convert a bit array into an int value.
+        /// </summary>
+        /// <param name="bits">The bit array to convert.</param>
+        /// <returns>The converted int value.</returns>
+        public int CreateIntegerFromBitArray(BitArray bits)
+        {
+            if (32 != bits.Length)
+            {
+                throw new ArgumentException(String.Format("Can only convert a bit array with 32-bits to integer. Actual number of bits in array: {0}", bits.Length), "bits");
+            }
+
+            int[] intArray = new int[1];
+            bits.CopyTo(intArray, 0);
+
+            return intArray[0];
+        }
+
+        /// <summary>
+        /// Sets a bit in a bit array based on the index at which an attribute name was found in a string array.
+        /// </summary>
+        /// <param name="attributeNames">Array of attributes that map to bits.</param>
+        /// <param name="attributeName">Name of attribute to check.</param>
+        /// <param name="attributeValue">Value of attribute to check.</param>
+        /// <param name="bits">The bit array in which the bit will be set if found.</param>
+        /// <param name="offset">The offset into the bit array.</param>
+        /// <returns>true if the bit was set; false otherwise.</returns>
+        public bool TrySetBitFromName(string[] attributeNames, string attributeName, YesNoType attributeValue, BitArray bits, int offset)
+        {
+            for (int i = 0; i < attributeNames.Length; i++)
+            {
+                if (attributeName.Equals(attributeNames[i], StringComparison.Ordinal))
+                {
+                    bits.Set(i + offset, YesNoType.Yes == attributeValue);
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Verifies that a filename is ambiguous.
+        /// </summary>
+        /// <param name="filename">Filename to verify.</param>
+        /// <returns>true if the filename is ambiguous; false otherwise.</returns>
+        public static bool IsAmbiguousFilename(string filename)
+        {
+            if (null == filename || 0 == filename.Length)
+            {
+                return false;
+            }
+
+            return CompilerCore.AmbiguousFilename.IsMatch(filename);
+        }
+
+        /// <summary>
+        /// Verifies that a value is a legal identifier.
+        /// </summary>
+        /// <param name="value">The value to verify.</param>
+        /// <returns>true if the value is an identifier; false otherwise.</returns>
+        public bool IsValidIdentifier(string value)
+        {
+            return Common.IsIdentifier(value);
+        }
+
+        /// <summary>
+        /// Verifies if an identifier is a valid loc identifier.
+        /// </summary>
+        /// <param name="identifier">Identifier to verify.</param>
+        /// <returns>True if the identifier is a valid loc identifier.</returns>
+        public bool IsValidLocIdentifier(string identifier)
+        {
+            if (String.IsNullOrEmpty(identifier))
+            {
+                return false;
+            }
+
+            Match match = Common.WixVariableRegex.Match(identifier);
+
+            return (match.Success && "loc" == match.Groups["namespace"].Value && 0 == match.Index && identifier.Length == match.Length);
+        }
+
+        /// <summary>
+        /// Verifies if a filename is a valid long filename.
+        /// </summary>
+        /// <param name="filename">Filename to verify.</param>
+        /// <param name="allowWildcards">true if wildcards are allowed in the filename.</param>
+        /// <param name="allowRelative">true if relative paths are allowed in the filename.</param>
+        /// <returns>True if the filename is a valid long filename</returns>
+        public bool IsValidLongFilename(string filename, bool allowWildcards = false, bool allowRelative = false)
+        {
+            if (String.IsNullOrEmpty(filename))
+            {
+                return false;
+            }
+
+            // check for a non-period character (all periods is not legal)
+            bool nonPeriodFound = false;
+            foreach (char character in filename)
+            {
+                if ('.' != character)
+                {
+                    nonPeriodFound = true;
+                    break;
+                }
+            }
+
+            if (allowWildcards)
+            {
+                return (nonPeriodFound && CompilerCore.LegalWildcardLongFilename.IsMatch(filename));
+            }
+            else if (allowRelative)
+            {
+                return (nonPeriodFound && CompilerCore.LegalRelativeLongFilename.IsMatch(filename));
+            }
+            else
+            {
+                return (nonPeriodFound && CompilerCore.LegalLongFilename.IsMatch(filename));
+            }
+        }
+
+        /// <summary>
+        /// Verifies if a filename is a valid short filename.
+        /// </summary>
+        /// <param name="filename">Filename to verify.</param>
+        /// <param name="allowWildcards">true if wildcards are allowed in the filename.</param>
+        /// <returns>True if the filename is a valid short filename</returns>
+        public bool IsValidShortFilename(string filename, bool allowWildcards)
+        {
+            return Common.IsValidShortFilename(filename, allowWildcards);
+        }
+
+        /// <summary>
+        /// Replaces the illegal filename characters to create a legal name.
+        /// </summary>
+        /// <param name="filename">Filename to make valid.</param>
+        /// <param name="replace">Replacement string for invalid characters in filename.</param>
+        /// <returns>Valid filename.</returns>
+        public static string MakeValidLongFileName(string filename, string replace)
+        {
+            return CompilerCore.IllegalLongFilename.Replace(filename, replace);
+        }
+
+        /// <summary>
+        /// Creates a short file/directory name using an identifier and long file/directory name as input.
+        /// </summary>
+        /// <param name="longName">The long file/directory name.</param>
+        /// <param name="keepExtension">The option to keep the extension on generated short names.</param>
+        /// <param name="allowWildcards">true if wildcards are allowed in the filename.</param>
+        /// <param name="args">Any additional information to include in the hash for the generated short name.</param>
+        /// <returns>The generated 8.3-compliant short file/directory name.</returns>
+        public string CreateShortName(string longName, bool keepExtension, bool allowWildcards, params string[] args)
+        {
+            // canonicalize the long name if its not a localization identifier (they are case-sensitive)
+            if (!this.IsValidLocIdentifier(longName))
+            {
+                longName = longName.ToLowerInvariant();
+            }
+
+            // collect all the data
+            List<string> strings = new List<string>(1 + args.Length);
+            strings.Add(longName);
+            strings.AddRange(args);
+
+            // prepare for hashing
+            string stringData = String.Join("|", strings);
+            byte[] data = Encoding.UTF8.GetBytes(stringData);
+
+            // hash the data
+            byte[] hash;
+            using (SHA1 sha1 = new SHA1CryptoServiceProvider())
+            {
+                hash = sha1.ComputeHash(data);
+            }
+
+            // generate the short file/directory name without an extension
+            StringBuilder shortName = new StringBuilder(Convert.ToBase64String(hash));
+            shortName.Remove(8, shortName.Length - 8).Replace('+', '-').Replace('/', '_');
+
+            if (keepExtension)
+            {
+                string extension = Path.GetExtension(longName);
+
+                if (4 < extension.Length)
+                {
+                    extension = extension.Substring(0, 4);
+                }
+
+                shortName.Append(extension);
+
+                // check the generated short name to ensure its still legal (the extension may not be legal)
+                if (!this.IsValidShortFilename(shortName.ToString(), allowWildcards))
+                {
+                    // remove the extension (by truncating the generated file name back to the generated characters)
+                    shortName.Length -= extension.Length;
+                }
+            }
+
+            return shortName.ToString().ToLowerInvariant();
+        }
+
+        /// <summary>
+        /// Verifies the given string is a valid product version.
+        /// </summary>
+        /// <param name="version">The product version to verify.</param>
+        /// <returns>True if version is a valid product version</returns>
+        public static bool IsValidProductVersion(string version)
+        {
+            if (!Common.IsValidBinderVariable(version))
+            {
+                Version ver = new Version(version);
+
+                if (255 < ver.Major || 255 < ver.Minor || 65535 < ver.Build)
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Verifies the given string is a valid module or bundle version.
+        /// </summary>
+        /// <param name="version">The version to verify.</param>
+        /// <returns>True if version is a valid module or bundle version.</returns>
+        public static bool IsValidModuleOrBundleVersion(string version)
+        {
+            return Common.IsValidModuleOrBundleVersion(version);
+        }
+
+        /// <summary>
+        /// Get an element's inner text and trims any extra whitespace.
+        /// </summary>
+        /// <param name="element">The element with inner text to be trimmed.</param>
+        /// <returns>The node's inner text trimmed.</returns>
+        public string GetTrimmedInnerText(XElement element)
+        {
+            string value = Common.GetInnerText(element);
+            return (null == value) ? null : value.Trim();
+        }
+
+        /// <summary>
+        /// Gets element's inner text and ensure's it is safe for use in a condition by trimming any extra whitespace.
+        /// </summary>
+        /// <param name="element">The element to ensure inner text is a condition.</param>
+        /// <returns>The value converted into a safe condition.</returns>
+        [SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes")]
+        public string GetConditionInnerText(XElement element)
+        {
+            string value = element.Value;
+            if (0 < value.Length)
+            {
+                value = value.Trim();
+                value = value.Replace('\t', ' ');
+                value = value.Replace('\r', ' ');
+                value = value.Replace('\n', ' ');
+            }
+            else // return null for a non-existant condition
+            {
+                value = null;
+            }
+
+            return value;
+        }
+
+        /// <summary>
+        /// Creates a version 3 name-based UUID.
+        /// </summary>
+        /// <param name="namespaceGuid">The namespace UUID.</param>
+        /// <param name="value">The value.</param>
+        /// <returns>The generated GUID for the given namespace and value.</returns>
+        public string CreateGuid(Guid namespaceGuid, string value)
+        {
+            return Uuid.NewUuid(namespaceGuid, value).ToString("B").ToUpperInvariant();
+        }
+
+        /// <summary>
+        /// Creates a row in the active section.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source and line number of current row.</param>
+        /// <param name="tableName">Name of table to create row in.</param>
+        /// <returns>New row.</returns>
+        public Row CreateRow(SourceLineNumber sourceLineNumbers, string tableName, Identifier identifier = null)
+        {
+            return this.CreateRow(sourceLineNumbers, tableName, this.ActiveSection, identifier);
+        }
+
+        /// <summary>
+        /// Creates a row in the active given <paramref name="section"/>.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source and line number of current row.</param>
+        /// <param name="tableName">Name of table to create row in.</param>
+        /// <param name="section">The section to which the row is added. If null, the row is added to the active section.</param>
+        /// <returns>New row.</returns>
+        internal Row CreateRow(SourceLineNumber sourceLineNumbers, string tableName, Section section, Identifier identifier = null)
+        {
+            TableDefinition tableDefinition = this.tableDefinitions[tableName];
+            Table table = section.EnsureTable(tableDefinition);
+            Row row = table.CreateRow(sourceLineNumbers);
+
+            if (null != identifier)
+            {
+                row.Access = identifier.Access;
+                row[0] = identifier.Id;
+            }
+
+            return row;
+        }
+
+        /// <summary>
+        /// Creates directories using the inline directory syntax.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information.</param>
+        /// <param name="attribute">The attribute to parse.</param>
+        /// <param name="parentId">Optional identifier of parent directory.</param>
+        /// <returns>Identifier of the leaf directory created.</returns>
+        public string CreateDirectoryReferenceFromInlineSyntax(SourceLineNumber sourceLineNumbers, XAttribute attribute, string parentId)
+        {
+            string id = null;
+            string[] inlineSyntax = this.GetAttributeInlineDirectorySyntax(sourceLineNumbers, attribute, true);
+
+            if (null != inlineSyntax)
+            {
+                // Special case the single entry in the inline syntax since it is the most common case
+                // and needs no extra processing. It's just a reference to an existing directory.
+                if (1 == inlineSyntax.Length)
+                {
+                    id = inlineSyntax[0];
+                    this.CreateSimpleReference(sourceLineNumbers, "Directory", id);
+                }
+                else // start creating rows for the entries in the inline syntax
+                {
+                    id = parentId;
+
+                    int pathStartsAt = 0;
+                    if (inlineSyntax[0].EndsWith(":"))
+                    {
+                        // TODO: should overriding the parent identifier with a specific id be an error or a warning or just let it slide?
+                        //if (null != parentId)
+                        //{
+                        //    this.core.OnMessage(WixErrors.Xxx(sourceLineNumbers));
+                        //}
+
+                        id = inlineSyntax[0].TrimEnd(':');
+                        this.CreateSimpleReference(sourceLineNumbers, "Directory", id);
+
+                        pathStartsAt = 1;
+                    }
+
+                    for (int i = pathStartsAt; i < inlineSyntax.Length; ++i)
+                    {
+                        Identifier inlineId = this.CreateDirectoryRow(sourceLineNumbers, null, id, inlineSyntax[i]);
+                        id = inlineId.Id;
+                    }
+                }
+            }
+
+            return id;
+        }
+
+        /// <summary>
+        /// Creates a patch resource reference to the list of resoures to be filtered when producing a patch. This method should only be used when processing children of a patch family.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source and line number of current row.</param>
+        /// <param name="tableName">Name of table to create row in.</param>
+        /// <param name="primaryKeys">Array of keys that make up the primary key of the table.</param>
+        /// <returns>New row.</returns>
+        public void CreatePatchFamilyChildReference(SourceLineNumber sourceLineNumbers, string tableName, params string[] primaryKeys)
+        {
+            Row patchReferenceRow = this.CreateRow(sourceLineNumbers, "WixPatchRef");
+            patchReferenceRow[0] = tableName;
+            patchReferenceRow[1] = String.Join("/", primaryKeys);
+        }
+
+        /// <summary>
+        /// Creates a Registry row in the active section.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source and line number of the current row.</param>
+        /// <param name="root">The registry entry root.</param>
+        /// <param name="key">The registry entry key.</param>
+        /// <param name="name">The registry entry name.</param>
+        /// <param name="value">The registry entry value.</param>
+        /// <param name="componentId">The component which will control installation/uninstallation of the registry entry.</param>
+        /// <param name="escapeLeadingHash">If true, "escape" leading '#' characters so the value is written as a REG_SZ.</param>
+        public Identifier CreateRegistryRow(SourceLineNumber sourceLineNumbers, int root, string key, string name, string value, string componentId, bool escapeLeadingHash)
+        {
+            Identifier id = null;
+
+            if (!this.EncounteredError)
+            {
+                if (-1 > root || 3 < root)
+                {
+                    throw new ArgumentOutOfRangeException("root");
+                }
+
+                if (null == key)
+                {
+                    throw new ArgumentNullException("key");
+                }
+
+                if (null == componentId)
+                {
+                    throw new ArgumentNullException("componentId");
+                }
+
+                // escape the leading '#' character for string registry values
+                if (escapeLeadingHash && null != value && value.StartsWith("#", StringComparison.Ordinal))
+                {
+                    value = String.Concat("#", value);
+                }
+
+                id = this.CreateIdentifier("reg", componentId, root.ToString(CultureInfo.InvariantCulture.NumberFormat), key.ToLowerInvariant(), (null != name ? name.ToLowerInvariant() : name));
+                Row row = this.CreateRow(sourceLineNumbers, "Registry", id);
+                row[1] = root;
+                row[2] = key;
+                row[3] = name;
+                row[4] = value;
+                row[5] = componentId;
+            }
+
+            return id;
+        }
+
+        /// <summary>
+        /// Creates a Registry row in the active section.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source and line number of the current row.</param>
+        /// <param name="root">The registry entry root.</param>
+        /// <param name="key">The registry entry key.</param>
+        /// <param name="name">The registry entry name.</param>
+        /// <param name="value">The registry entry value.</param>
+        /// <param name="componentId">The component which will control installation/uninstallation of the registry entry.</param>
+        public Identifier CreateRegistryRow(SourceLineNumber sourceLineNumbers, int root, string key, string name, string value, string componentId)
+        {
+            return this.CreateRegistryRow(sourceLineNumbers, root, key, name, value, componentId, true);
+        }
+
+        /// <summary>
+        /// Create a WixSimpleReference row in the active section.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information for the row.</param>
+        /// <param name="tableName">The table name of the simple reference.</param>
+        /// <param name="primaryKeys">The primary keys of the simple reference.</param>
+        public void CreateSimpleReference(SourceLineNumber sourceLineNumbers, string tableName, params string[] primaryKeys)
+        {
+            if (!this.EncounteredError)
+            {
+                string joinedKeys = String.Join("/", primaryKeys);
+                string id = String.Concat(tableName, ":", joinedKeys);
+
+                // If this simple reference hasn't been added to the active section already, add it.
+                if (this.activeSectionSimpleReferences.Add(id))
+                {
+                    WixSimpleReferenceRow wixSimpleReferenceRow = (WixSimpleReferenceRow)this.CreateRow(sourceLineNumbers, "WixSimpleReference");
+                    wixSimpleReferenceRow.TableName = tableName;
+                    wixSimpleReferenceRow.PrimaryKeys = joinedKeys;
+                }
+            }
+        }
+
+        /// <summary>
+        /// A row in the WixGroup table is added for this child node and its parent node.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information for the row.</param>
+        /// <param name="parentType">Type of child's complex reference parent.</param>
+        /// <param name="parentId">Id of the parenet node.</param>
+        /// <param name="childType">Complex reference type of child</param>
+        /// <param name="childId">Id of the Child Node.</param>
+        public void CreateWixGroupRow(SourceLineNumber sourceLineNumbers, ComplexReferenceParentType parentType, string parentId, ComplexReferenceChildType childType, string childId)
+        {
+            if (!this.EncounteredError)
+            {
+                if (null == parentId || ComplexReferenceParentType.Unknown == parentType)
+                {
+                    return;
+                }
+
+                if (null == childId)
+                {
+                    throw new ArgumentNullException("childId");
+                }
+
+                WixGroupRow WixGroupRow = (WixGroupRow)this.CreateRow(sourceLineNumbers, "WixGroup");
+                WixGroupRow.ParentId = parentId;
+                WixGroupRow.ParentType = parentType;
+                WixGroupRow.ChildId = childId;
+                WixGroupRow.ChildType = childType;
+            }
+        }
+
+        /// <summary>
+        /// Add the appropriate rows to make sure that the given table shows up
+        /// in the resulting output.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line numbers.</param>
+        /// <param name="tableName">Name of the table to ensure existance of.</param>
+        public void EnsureTable(SourceLineNumber sourceLineNumbers, string tableName)
+        {
+            if (!this.EncounteredError)
+            {
+                Row row = this.CreateRow(sourceLineNumbers, "WixEnsureTable");
+                row[0] = tableName;
+
+                // We don't add custom table definitions to the tableDefinitions collection,
+                // so if it's not in there, it better be a custom table. If the Id is just wrong,
+                // instead of a custom table, we get an unresolved reference at link time.
+                if (!this.tableDefinitions.Contains(tableName))
+                {
+                    this.CreateSimpleReference(sourceLineNumbers, "WixCustomTable", tableName);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Get an attribute value.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information about the owner element.</param>
+        /// <param name="attribute">The attribute containing the value to get.</param>
+        /// <param name="emptyRule">A rule for the contents of the value. If the contents do not follow the rule, an error is thrown.</param>
+        /// <returns>The attribute's value.</returns>
+        [SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes")]
+        public string GetAttributeValue(SourceLineNumber sourceLineNumbers, XAttribute attribute, EmptyRule emptyRule = EmptyRule.CanBeWhitespaceOnly)
+        {
+            return Common.GetAttributeValue(sourceLineNumbers, attribute, emptyRule);
+        }
+
+        /// <summary>
+        /// Get a valid code page by web name or number from a string attribute.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information about the owner element.</param>
+        /// <param name="attribute">The attribute containing the value to get.</param>
+        /// <returns>A valid code page integer value.</returns>
+        [SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes")]
+        public int GetAttributeCodePageValue(SourceLineNumber sourceLineNumbers, XAttribute attribute)
+        {
+            if (null == attribute)
+            {
+                throw new ArgumentNullException("attribute");
+            }
+
+            string value = this.GetAttributeValue(sourceLineNumbers, attribute);
+
+            try
+            {
+                int codePage = Common.GetValidCodePage(value);
+                return codePage;
+            }
+            catch (NotSupportedException)
+            {
+                this.OnMessage(WixErrors.IllegalCodepageAttribute(sourceLineNumbers, value, attribute.Parent.Name.LocalName, attribute.Name.LocalName));
+            }
+
+            return CompilerConstants.IllegalInteger;
+        }
+
+        /// <summary>
+        /// Get a valid code page by web name or number from a string attribute.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information about the owner element.</param>
+        /// <param name="attribute">The attribute containing the value to get.</param>
+        /// <param name="onlyAscii">Whether to allow Unicode (UCS) or UTF code pages.</param>
+        /// <returns>A valid code page integer value or variable expression.</returns>
+        [SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes")]
+        public string GetAttributeLocalizableCodePageValue(SourceLineNumber sourceLineNumbers, XAttribute attribute, bool onlyAnsi = false)
+        {
+            if (null == attribute)
+            {
+                throw new ArgumentNullException("attribute");
+            }
+
+            string value = this.GetAttributeValue(sourceLineNumbers, attribute);
+
+            // allow for localization of code page names and values
+            if (IsValidLocIdentifier(value))
+            {
+                return value;
+            }
+
+            try
+            {
+                int codePage = Common.GetValidCodePage(value, false, onlyAnsi, sourceLineNumbers);
+                return codePage.ToString(CultureInfo.InvariantCulture);
+            }
+            catch (NotSupportedException)
+            {
+                // not a valid windows code page
+                this.OnMessage(WixErrors.IllegalCodepageAttribute(sourceLineNumbers, value, attribute.Parent.Name.LocalName, attribute.Name.LocalName));
+            }
+            catch (WixException e)
+            {
+                this.OnMessage(e.Error);
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Get an integer attribute value and displays an error for an illegal integer value.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information about the owner element.</param>
+        /// <param name="attribute">The attribute containing the value to get.</param>
+        /// <param name="minimum">The minimum legal value.</param>
+        /// <param name="maximum">The maximum legal value.</param>
+        /// <returns>The attribute's integer value or a special value if an error occurred during conversion.</returns>
+        [SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes")]
+        public int GetAttributeIntegerValue(SourceLineNumber sourceLineNumbers, XAttribute attribute, int minimum, int maximum)
+        {
+            return Common.GetAttributeIntegerValue(sourceLineNumbers, attribute, minimum, maximum);
+        }
+
+        /// <summary>
+        /// Get a long integral attribute value and displays an error for an illegal long value.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information about the owner element.</param>
+        /// <param name="attribute">The attribute containing the value to get.</param>
+        /// <param name="minimum">The minimum legal value.</param>
+        /// <param name="maximum">The maximum legal value.</param>
+        /// <returns>The attribute's long value or a special value if an error occurred during conversion.</returns>
+        public long GetAttributeLongValue(SourceLineNumber sourceLineNumbers, XAttribute attribute, long minimum, long maximum)
+        {
+            Debug.Assert(minimum > CompilerConstants.LongNotSet && minimum > CompilerConstants.IllegalLong, "The legal values for this attribute collide with at least one sentinel used during parsing.");
+
+            string value = this.GetAttributeValue(sourceLineNumbers, attribute);
+
+            if (0 < value.Length)
+            {
+                try
+                {
+                    long longValue = Convert.ToInt64(value, CultureInfo.InvariantCulture.NumberFormat);
+
+                    if (CompilerConstants.LongNotSet == longValue || CompilerConstants.IllegalLong == longValue)
+                    {
+                        this.OnMessage(WixErrors.IntegralValueSentinelCollision(sourceLineNumbers, longValue));
+                    }
+                    else if (minimum > longValue || maximum < longValue)
+                    {
+                        this.OnMessage(WixErrors.IntegralValueOutOfRange(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, longValue, minimum, maximum));
+                        longValue = CompilerConstants.IllegalLong;
+                    }
+
+                    return longValue;
+                }
+                catch (FormatException)
+                {
+                    this.OnMessage(WixErrors.IllegalLongValue(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value));
+                }
+                catch (OverflowException)
+                {
+                    this.OnMessage(WixErrors.IllegalLongValue(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value));
+                }
+            }
+
+            return CompilerConstants.IllegalLong;
+        }
+
+        /// <summary>
+        /// Get a date time attribute value and display errors for illegal values.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information about the owner element.</param>
+        /// <param name="attribute">The attribute containing the value to get.</param>
+        /// <returns>Int representation of the date time.</returns>
+        [SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes")]
+        public int GetAttributeDateTimeValue(SourceLineNumber sourceLineNumbers, XAttribute attribute)
+        {
+            if (null == attribute)
+            {
+                throw new ArgumentNullException("attribute");
+            }
+
+            string value = this.GetAttributeValue(sourceLineNumbers, attribute);
+
+            if (0 < value.Length)
+            {
+                try
+                {
+                    DateTime date = DateTime.Parse(value, CultureInfo.InvariantCulture.DateTimeFormat);
+
+                    return ((((date.Year - 1980) * 512) + (date.Month * 32 + date.Day)) * 65536) +
+                        (date.Hour * 2048) + (date.Minute * 32) + (date.Second / 2);
+                }
+                catch (ArgumentOutOfRangeException)
+                {
+                    this.OnMessage(WixErrors.InvalidDateTimeFormat(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value));
+                }
+                catch (FormatException)
+                {
+                    this.OnMessage(WixErrors.InvalidDateTimeFormat(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value));
+                }
+                catch (OverflowException)
+                {
+                    this.OnMessage(WixErrors.InvalidDateTimeFormat(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value));
+                }
+            }
+
+            return CompilerConstants.IllegalInteger;
+        }
+
+        /// <summary>
+        /// Get an integer attribute value or localize variable and displays an error for
+        /// an illegal value.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information about the owner element.</param>
+        /// <param name="attribute">The attribute containing the value to get.</param>
+        /// <param name="minimum">The minimum legal value.</param>
+        /// <param name="maximum">The maximum legal value.</param>
+        /// <returns>The attribute's integer value or localize variable as a string or a special value if an error occurred during conversion.</returns>
+        public string GetAttributeLocalizableIntegerValue(SourceLineNumber sourceLineNumbers, XAttribute attribute, int minimum, int maximum)
+        {
+            if (null == attribute)
+            {
+                throw new ArgumentNullException("attribute");
+            }
+
+            Debug.Assert(minimum > CompilerConstants.IntegerNotSet && minimum > CompilerConstants.IllegalInteger, "The legal values for this attribute collide with at least one sentinel used during parsing.");
+
+            string value = this.GetAttributeValue(sourceLineNumbers, attribute);
+
+            if (0 < value.Length)
+            {
+                if (IsValidLocIdentifier(value) || Common.IsValidBinderVariable(value))
+                {
+                    return value;
+                }
+                else
+                {
+                    try
+                    {
+                        int integer = Convert.ToInt32(value, CultureInfo.InvariantCulture.NumberFormat);
+
+                        if (CompilerConstants.IntegerNotSet == integer || CompilerConstants.IllegalInteger == integer)
+                        {
+                            this.OnMessage(WixErrors.IntegralValueSentinelCollision(sourceLineNumbers, integer));
+                        }
+                        else if (minimum > integer || maximum < integer)
+                        {
+                            this.OnMessage(WixErrors.IntegralValueOutOfRange(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, integer, minimum, maximum));
+                            integer = CompilerConstants.IllegalInteger;
+                        }
+
+                        return value;
+                    }
+                    catch (FormatException)
+                    {
+                        this.OnMessage(WixErrors.IllegalIntegerValue(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value));
+                    }
+                    catch (OverflowException)
+                    {
+                        this.OnMessage(WixErrors.IllegalIntegerValue(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value));
+                    }
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Get a guid attribute value and displays an error for an illegal guid value.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information about the owner element.</param>
+        /// <param name="attribute">The attribute containing the value to get.</param>
+        /// <param name="generatable">Determines whether the guid can be automatically generated.</param>
+        /// <param name="canBeEmpty">If true, no error is raised on empty value. If false, an error is raised.</param>
+        /// <returns>The attribute's guid value or a special value if an error occurred.</returns>
+        [SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes")]
+        [SuppressMessage("Microsoft.Performance", "CA1807:AvoidUnnecessaryStringCreation")]
+        public string GetAttributeGuidValue(SourceLineNumber sourceLineNumbers, XAttribute attribute, bool generatable = false, bool canBeEmpty = false)
+        {
+            if (null == attribute)
+            {
+                throw new ArgumentNullException("attribute");
+            }
+
+            EmptyRule emptyRule = canBeEmpty ? EmptyRule.CanBeEmpty : EmptyRule.CanBeWhitespaceOnly;
+            string value = this.GetAttributeValue(sourceLineNumbers, attribute, emptyRule);
+
+            if (String.IsNullOrEmpty(value) && canBeEmpty)
+            {
+                return String.Empty;
+            }
+            else if (!String.IsNullOrEmpty(value))
+            {
+                // If the value starts and ends with braces or parenthesis, accept that and strip them off.
+                if ((value.StartsWith("{", StringComparison.Ordinal) && value.EndsWith("}", StringComparison.Ordinal))
+                    || (value.StartsWith("(", StringComparison.Ordinal) && value.EndsWith(")", StringComparison.Ordinal)))
+                {
+                    value = value.Substring(1, value.Length - 2);
+                }
+
+                try
+                {
+                    Guid guid;
+
+                    if (generatable && "*".Equals(value, StringComparison.Ordinal))
+                    {
+                        return value;
+                    }
+
+                    if (CompilerCore.PutGuidHere.IsMatch(value))
+                    {
+                        this.OnMessage(WixErrors.ExampleGuid(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value));
+                        return CompilerConstants.IllegalGuid;
+                    }
+                    else if (value.StartsWith("!(loc", StringComparison.Ordinal) || value.StartsWith("$(loc", StringComparison.Ordinal) || value.StartsWith("!(wix", StringComparison.Ordinal))
+                    {
+                        return value;
+                    }
+                    else
+                    {
+                        guid = new Guid(value);
+                    }
+
+                    string uppercaseGuid = guid.ToString().ToUpper(CultureInfo.InvariantCulture);
+
+                    if (this.showPedanticMessages)
+                    {
+                        if (uppercaseGuid != value)
+                        {
+                            this.OnMessage(WixErrors.GuidContainsLowercaseLetters(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value));
+                        }
+                    }
+
+                    return String.Concat("{", uppercaseGuid, "}");
+                }
+                catch (FormatException)
+                {
+                    this.OnMessage(WixErrors.IllegalGuidValue(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value));
+                }
+            }
+
+            return CompilerConstants.IllegalGuid;
+        }
+
+        /// <summary>
+        /// Get an identifier attribute value and displays an error for an illegal identifier value.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information about the owner element.</param>
+        /// <param name="attribute">The attribute containing the value to get.</param>
+        /// <returns>The attribute's identifier value or a special value if an error occurred.</returns>
+        public Identifier GetAttributeIdentifier(SourceLineNumber sourceLineNumbers, XAttribute attribute)
+        {
+            string value = Common.GetAttributeValue(sourceLineNumbers, attribute, EmptyRule.CanBeEmpty);
+            AccessModifier access = AccessModifier.Public;
+
+            Match match = CompilerCore.LegalIdentifierWithAccess.Match(value);
+            if (!match.Success)
+            {
+                return null;
+            }
+            else if (match.Groups["access"].Success)
+            {
+                access = (AccessModifier)Enum.Parse(typeof(AccessModifier), match.Groups["access"].Value, true);
+            }
+
+            value = match.Groups["id"].Value;
+
+            if (Common.IsIdentifier(value) && 72 < value.Length)
+            {
+                this.OnMessage(WixWarnings.IdentifierTooLong(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value));
+            }
+
+            return new Identifier(value, access);
+        }
+
+        /// <summary>
+        /// Get an identifier attribute value and displays an error for an illegal identifier value.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information about the owner element.</param>
+        /// <param name="attribute">The attribute containing the value to get.</param>
+        /// <returns>The attribute's identifier value or a special value if an error occurred.</returns>
+        public string GetAttributeIdentifierValue(SourceLineNumber sourceLineNumbers, XAttribute attribute)
+        {
+            return Common.GetAttributeIdentifierValue(sourceLineNumbers, attribute);
+        }
+
+        /// <summary>
+        /// Gets a yes/no value and displays an error for an illegal yes/no value.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information about the owner element.</param>
+        /// <param name="attribute">The attribute containing the value to get.</param>
+        /// <returns>The attribute's YesNoType value.</returns>
+        public YesNoType GetAttributeYesNoValue(SourceLineNumber sourceLineNumbers, XAttribute attribute)
+        {
+            string value = this.GetAttributeValue(sourceLineNumbers, attribute);
+
+            YesNoType result = YesNoType.IllegalValue;
+            if (value.Equals("yes") || value.Equals("true"))
+            {
+                result = YesNoType.Yes;
+            }
+            else if (value.Equals("no") || value.Equals("false"))
+            {
+                result = YesNoType.No;
+            }
+            else
+            {
+                this.OnMessage(WixErrors.IllegalYesNoValue(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value));
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Gets a yes/no/default value and displays an error for an illegal yes/no value.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information about the owner element.</param>
+        /// <param name="attribute">The attribute containing the value to get.</param>
+        /// <returns>The attribute's YesNoDefaultType value.</returns>
+        [SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes")]
+        public YesNoDefaultType GetAttributeYesNoDefaultValue(SourceLineNumber sourceLineNumbers, XAttribute attribute)
+        {
+            string value = this.GetAttributeValue(sourceLineNumbers, attribute);
+
+            if (0 < value.Length)
+            {
+                switch (Wix.Enums.ParseYesNoDefaultType(value))
+                {
+                    case Wix.YesNoDefaultType.@default:
+                        return YesNoDefaultType.Default;
+                    case Wix.YesNoDefaultType.no:
+                        return YesNoDefaultType.No;
+                    case Wix.YesNoDefaultType.yes:
+                        return YesNoDefaultType.Yes;
+                    case Wix.YesNoDefaultType.NotSet:
+                        // Previous code never returned 'NotSet'!
+                        break;
+                    default:
+                        this.OnMessage(WixErrors.IllegalYesNoDefaultValue(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value));
+                        break;
+                }
+            }
+
+            return YesNoDefaultType.IllegalValue;
+        }
+
+        /// <summary>
+        /// Gets a yes/no/always value and displays an error for an illegal value.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information about the owner element.</param>
+        /// <param name="attribute">The attribute containing the value to get.</param>
+        /// <returns>The attribute's YesNoAlwaysType value.</returns>
+        [SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes")]
+        public YesNoAlwaysType GetAttributeYesNoAlwaysValue(SourceLineNumber sourceLineNumbers, XAttribute attribute)
+        {
+            string value = this.GetAttributeValue(sourceLineNumbers, attribute);
+
+            if (0 < value.Length)
+            {
+                switch (Wix.Enums.ParseYesNoAlwaysType(value))
+                {
+                    case Wix.YesNoAlwaysType.@always:
+                        return YesNoAlwaysType.Always;
+                    case Wix.YesNoAlwaysType.no:
+                        return YesNoAlwaysType.No;
+                    case Wix.YesNoAlwaysType.yes:
+                        return YesNoAlwaysType.Yes;
+                    case Wix.YesNoAlwaysType.NotSet:
+                        // Previous code never returned 'NotSet'!
+                        break;
+                    default:
+                        this.OnMessage(WixErrors.IllegalYesNoAlwaysValue(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value));
+                        break;
+                }
+            }
+
+            return YesNoAlwaysType.IllegalValue;
+        }
+
+        /// <summary>
+        /// Gets a short filename value and displays an error for an illegal short filename value.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information about the owner element.</param>
+        /// <param name="attribute">The attribute containing the value to get.</param>
+        /// <param name="allowWildcards">true if wildcards are allowed in the filename.</param>
+        /// <returns>The attribute's short filename value.</returns>
+        public string GetAttributeShortFilename(SourceLineNumber sourceLineNumbers, XAttribute attribute, bool allowWildcards)
+        {
+            if (null == attribute)
+            {
+                throw new ArgumentNullException("attribute");
+            }
+
+            string value = this.GetAttributeValue(sourceLineNumbers, attribute);
+
+            if (0 < value.Length)
+            {
+                if (!this.IsValidShortFilename(value, allowWildcards) && !this.IsValidLocIdentifier(value))
+                {
+                    this.OnMessage(WixErrors.IllegalShortFilename(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value));
+                }
+                else if (CompilerCore.IsAmbiguousFilename(value))
+                {
+                    this.OnMessage(WixWarnings.AmbiguousFileOrDirectoryName(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value));
+                }
+            }
+
+            return value;
+        }
+
+        /// <summary>
+        /// Gets a long filename value and displays an error for an illegal long filename value.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information about the owner element.</param>
+        /// <param name="attribute">The attribute containing the value to get.</param>
+        /// <param name="allowWildcards">true if wildcards are allowed in the filename.</param>
+        /// <param name="allowRelative">true if relative paths are allowed in the filename.</param>
+        /// <returns>The attribute's long filename value.</returns>
+        [SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes")]
+        public string GetAttributeLongFilename(SourceLineNumber sourceLineNumbers, XAttribute attribute, bool allowWildcards = false, bool allowRelative = false)
+        {
+            if (null == attribute)
+            {
+                throw new ArgumentNullException("attribute");
+            }
+
+            string value = this.GetAttributeValue(sourceLineNumbers, attribute);
+
+            if (0 < value.Length)
+            {
+                if (!this.IsValidLongFilename(value, allowWildcards, allowRelative) && !this.IsValidLocIdentifier(value))
+                {
+                    if (allowRelative)
+                    {
+                        this.OnMessage(WixErrors.IllegalRelativeLongFilename(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value));
+                    }
+                    else
+                    {
+                        this.OnMessage(WixErrors.IllegalLongFilename(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value));
+                    }
+                }
+                else if (allowRelative)
+                {
+                    string normalizedPath = value.Replace('\\', '/');
+                    if (normalizedPath.StartsWith("../", StringComparison.Ordinal) || normalizedPath.Contains("/../"))
+                    {
+                        this.OnMessage(WixErrors.PayloadMustBeRelativeToCache(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value));
+                    }
+                }
+                else if (CompilerCore.IsAmbiguousFilename(value))
+                {
+                    this.OnMessage(WixWarnings.AmbiguousFileOrDirectoryName(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value));
+                }
+            }
+
+            return value;
+        }
+
+        /// <summary>
+        /// Gets a version value or possibly a binder variable and displays an error for an illegal version value.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information about the owner element.</param>
+        /// <param name="attribute">The attribute containing the value to get.</param>
+        /// <returns>The attribute's version value.</returns>
+        public string GetAttributeVersionValue(SourceLineNumber sourceLineNumbers, XAttribute attribute)
+        {
+            string value = this.GetAttributeValue(sourceLineNumbers, attribute);
+
+            if (!String.IsNullOrEmpty(value))
+            {
+                try
+                {
+                    return new Version(value).ToString();
+                }
+                catch (FormatException) // illegal integer in version
+                {
+                    // Allow versions to contain binder variables.
+                    if (Common.ContainsValidBinderVariable(value))
+                    {
+                        return value;
+                    }
+
+                    this.OnMessage(WixErrors.IllegalVersionValue(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value));
+                }
+                catch (ArgumentException)
+                {
+                    this.OnMessage(WixErrors.IllegalVersionValue(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value));
+                }
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Gets a RegistryRoot value and displays an error for an illegal value.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information about the owner element.</param>
+        /// <param name="attribute">The attribute containing the value to get.</param>
+        /// <param name="allowHkmu">Whether HKMU is considered a valid value.</param>
+        /// <returns>The attribute's RegisitryRootType value.</returns>
+        [SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes")]
+        public Wix.RegistryRootType GetAttributeRegistryRootValue(SourceLineNumber sourceLineNumbers, XAttribute attribute, bool allowHkmu)
+        {
+            Wix.RegistryRootType registryRoot = Wix.RegistryRootType.NotSet;
+            string value = this.GetAttributeValue(sourceLineNumbers, attribute);
+
+            if (0 < value.Length)
+            {
+                registryRoot = Wix.Enums.ParseRegistryRootType(value);
+
+                if (Wix.RegistryRootType.IllegalValue == registryRoot || (!allowHkmu && Wix.RegistryRootType.HKMU == registryRoot))
+                {
+                    // TODO: Find a way to expose the valid values programatically!
+                    if (allowHkmu)
+                    {
+                        this.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value,
+                            "HKMU", "HKCR", "HKCU", "HKLM", "HKU"));
+                    }
+                    else
+                    {
+                        this.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value,
+                            "HKCR", "HKCU", "HKLM", "HKU"));
+                    }
+                }
+            }
+
+            return registryRoot;
+        }
+
+        /// <summary>
+        /// Gets a RegistryRoot as a MsiInterop.MsidbRegistryRoot value and displays an error for an illegal value.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information about the owner element.</param>
+        /// <param name="attribute">The attribute containing the value to get.</param>
+        /// <param name="allowHkmu">Whether HKMU is returned as -1 (true), or treated as an error (false).</param>
+        /// <returns>The attribute's RegisitryRootType value.</returns>
+        [SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes")]
+        public int GetAttributeMsidbRegistryRootValue(SourceLineNumber sourceLineNumbers, XAttribute attribute, bool allowHkmu)
+        {
+            Wix.RegistryRootType registryRoot = this.GetAttributeRegistryRootValue(sourceLineNumbers, attribute, allowHkmu);
+
+            switch (registryRoot)
+            {
+                case Wix.RegistryRootType.NotSet:
+                    return CompilerConstants.IntegerNotSet;
+                case Wix.RegistryRootType.HKCR:
+                    return Core.Native.MsiInterop.MsidbRegistryRootClassesRoot;
+                case Wix.RegistryRootType.HKCU:
+                    return Core.Native.MsiInterop.MsidbRegistryRootCurrentUser;
+                case Wix.RegistryRootType.HKLM:
+                    return Core.Native.MsiInterop.MsidbRegistryRootLocalMachine;
+                case Wix.RegistryRootType.HKU:
+                    return Core.Native.MsiInterop.MsidbRegistryRootUsers;
+                case Wix.RegistryRootType.HKMU:
+                    // This is gross, but there was *one* registry root parsing instance
+                    // (in Compiler.ParseRegistrySearchElement()) that did not explicitly
+                    // handle HKMU and it fell through to the default error case. The
+                    // others treated it as -1, which is what we do here.
+                    if (allowHkmu)
+                    {
+                        return -1;
+                    }
+                    break;
+            }
+
+            return CompilerConstants.IntegerNotSet;
+        }
+
+        /// <summary>
+        /// Gets an InstallUninstallType value and displays an error for an illegal value.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information about the owner element.</param>
+        /// <param name="attribute">The attribute containing the value to get.</param>
+        /// <returns>The attribute's InstallUninstallType value.</returns>
+        [SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes")]
+        public Wix.InstallUninstallType GetAttributeInstallUninstallValue(SourceLineNumber sourceLineNumbers, XAttribute attribute)
+        {
+            Wix.InstallUninstallType installUninstall = Wix.InstallUninstallType.NotSet;
+            string value = this.GetAttributeValue(sourceLineNumbers, attribute);
+
+            if (0 < value.Length)
+            {
+                installUninstall = Wix.Enums.ParseInstallUninstallType(value);
+
+                if (Wix.InstallUninstallType.IllegalValue == installUninstall)
+                {
+                    // TODO: Find a way to expose the valid values programatically!
+                    this.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value,
+                         "install", "uninstall", "both"));
+                }
+            }
+
+            return installUninstall;
+        }
+
+        /// <summary>
+        /// Gets an ExitType value and displays an error for an illegal value.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information about the owner element.</param>
+        /// <param name="attribute">The attribute containing the value to get.</param>
+        /// <returns>The attribute's ExitType value.</returns>
+        [SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes")]
+        public Wix.ExitType GetAttributeExitValue(SourceLineNumber sourceLineNumbers, XAttribute attribute)
+        {
+            string value = this.GetAttributeValue(sourceLineNumbers, attribute);
+
+            Wix.ExitType result = Wix.ExitType.NotSet;
+            if (!Enum.TryParse<Wix.ExitType>(value, out result))
+            {
+                result = Wix.ExitType.IllegalValue;
+
+                // TODO: Find a way to expose the valid values programatically!
+                this.OnMessage(WixErrors.IllegalAttributeValue(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value,
+                     "success", "cancel", "error", "suspend"));
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Gets a Bundle variable value and displays an error for an illegal value.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information about the owner element.</param>
+        /// <param name="attribute">The attribute containing the value to get.</param>
+        /// <returns>The attribute's value.</returns>
+        [SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes")]
+        public string GetAttributeBundleVariableValue(SourceLineNumber sourceLineNumbers, XAttribute attribute)
+        {
+            string value = this.GetAttributeValue(sourceLineNumbers, attribute);
+
+            if (!String.IsNullOrEmpty(value))
+            {
+                if (CompilerCore.BuiltinBundleVariables.Contains(value))
+                {
+                    string illegalValues = CompilerCore.CreateValueList(ValueListKind.Or, CompilerCore.BuiltinBundleVariables);
+                    this.OnMessage(WixErrors.IllegalAttributeValueWithIllegalList(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value, illegalValues));
+                }
+            }
+
+            return value;
+        }
+
+        /// <summary>
+        /// Gets an MsiProperty name value and displays an error for an illegal value.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information about the owner element.</param>
+        /// <param name="attribute">The attribute containing the value to get.</param>
+        /// <returns>The attribute's value.</returns>
+        [SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes")]
+        public string GetAttributeMsiPropertyNameValue(SourceLineNumber sourceLineNumbers, XAttribute attribute)
+        {
+            string value = this.GetAttributeValue(sourceLineNumbers, attribute);
+
+            if (0 < value.Length)
+            {
+                if (CompilerCore.DisallowedMsiProperties.Contains(value))
+                {
+                    string illegalValues = CompilerCore.CreateValueList(ValueListKind.Or, CompilerCore.DisallowedMsiProperties);
+                    this.OnMessage(WixErrors.DisallowedMsiProperty(sourceLineNumbers, value, illegalValues));
+                }
+            }
+
+            return value;
+        }
+
+        /// <summary>
+        /// Checks if the string contains a property (i.e. "foo[Property]bar")
+        /// </summary>
+        /// <param name="possibleProperty">String to evaluate for properties.</param>
+        /// <returns>True if a property is found in the string.</returns>
+        public bool ContainsProperty(string possibleProperty)
+        {
+            return Common.ContainsProperty(possibleProperty);
+        }
+
+        /// <summary>
+        /// Generate an identifier by hashing data from the row.
+        /// </summary>
+        /// <param name="prefix">Three letter or less prefix for generated row identifier.</param>
+        /// <param name="args">Information to hash.</param>
+        /// <returns>The generated identifier.</returns>
+        [SuppressMessage("Microsoft.Globalization", "CA1303:DoNotPassLiteralsAsLocalizedParameters", MessageId = "System.InvalidOperationException.#ctor(System.String)")]
+        public Identifier CreateIdentifier(string prefix, params string[] args)
+        {
+            string id = Common.GenerateIdentifier(prefix, args);
+            return new Identifier(id, AccessModifier.Private);
+        }
+
+        /// <summary>
+        /// Create an identifier based on passed file name
+        /// </summary>
+        /// <param name="name">File name to generate identifer from</param>
+        /// <returns></returns>
+        public Identifier CreateIdentifierFromFilename(string filename)
+        {
+            string id = Common.GetIdentifierFromName(filename);
+            return new Identifier(id, AccessModifier.Private);
+        }
+
+        /// <summary>
+        /// Attempts to use an extension to parse the attribute.
+        /// </summary>
+        /// <param name="element">Element containing attribute to be parsed.</param>
+        /// <param name="attribute">Attribute to be parsed.</param>
+        /// <param name="context">Extra information about the context in which this element is being parsed.</param>
+        public void ParseExtensionAttribute(XElement element, XAttribute attribute, IDictionary<string, string> context = null)
+        {
+            // Ignore attributes defined by the W3C because we'll assume they are always right.
+            if ((String.IsNullOrEmpty(attribute.Name.NamespaceName) && attribute.Name.LocalName.Equals("xmlns", StringComparison.Ordinal)) ||
+                attribute.Name.NamespaceName.StartsWith(CompilerCore.W3SchemaPrefix.NamespaceName, StringComparison.Ordinal))
+            {
+                return;
+            }
+
+            ICompilerExtension extension;
+            if (this.TryFindExtension(attribute.Name.NamespaceName, out extension))
+            {
+                extension.ParseAttribute(element, attribute, context);
+            }
+            else
+            {
+                SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(element);
+                this.OnMessage(WixErrors.UnhandledExtensionAttribute(sourceLineNumbers, element.Name.LocalName, attribute.Name.LocalName, attribute.Name.NamespaceName));
+            }
+        }
+
+        /// <summary>
+        /// Attempts to use an extension to parse the element.
+        /// </summary>
+        /// <param name="parentElement">Element containing element to be parsed.</param>
+        /// <param name="element">Element to be parsed.</param>
+        /// <param name="context">Extra information about the context in which this element is being parsed.</param>
+        public void ParseExtensionElement(XElement parentElement, XElement element, IDictionary<string, string> context = null)
+        {
+            ICompilerExtension extension;
+            if (this.TryFindExtension(element.Name.Namespace, out extension))
+            {
+                SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(parentElement);
+                extension.ParseElement(parentElement, element, context);
+            }
+            else
+            {
+                SourceLineNumber childSourceLineNumbers = Preprocessor.GetSourceLineNumbers(element);
+                this.OnMessage(WixErrors.UnhandledExtensionElement(childSourceLineNumbers, parentElement.Name.LocalName, element.Name.LocalName, element.Name.NamespaceName));
+            }
+        }
+
+        /// <summary>
+        /// Process all children of the element looking for extensions and erroring on the unexpected.
+        /// </summary>
+        /// <param name="element">Element to parse children.</param>
+        public void ParseForExtensionElements(XElement element)
+        {
+            foreach (XElement child in element.Elements())
+            {
+                if (element.Name.Namespace == child.Name.Namespace)
+                {
+                    this.UnexpectedElement(element, child);
+                }
+                else
+                {
+                    this.ParseExtensionElement(element, child);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Attempts to use an extension to parse the element, with support for setting component keypath.
+        /// </summary>
+        /// <param name="parentElement">Element containing element to be parsed.</param>
+        /// <param name="element">Element to be parsed.</param>
+        /// <param name="contextValues">Extra information about the context in which this element is being parsed.</param>
+        public ComponentKeyPath ParsePossibleKeyPathExtensionElement(XElement parentElement, XElement element, IDictionary<string, string> context)
+        {
+            ComponentKeyPath keyPath = null;
+
+            ICompilerExtension extension;
+            if (this.TryFindExtension(element.Name.Namespace, out extension))
+            {
+                keyPath = extension.ParsePossibleKeyPathElement(parentElement, element, context);
+            }
+            else
+            {
+                SourceLineNumber childSourceLineNumbers = Preprocessor.GetSourceLineNumbers(element);
+                this.OnMessage(WixErrors.UnhandledExtensionElement(childSourceLineNumbers, parentElement.Name.LocalName, element.Name.LocalName, element.Name.NamespaceName));
+            }
+
+            return keyPath;
+        }
+
+        /// <summary>
+        /// Displays an unexpected attribute error if the attribute is not the namespace attribute.
+        /// </summary>
+        /// <param name="element">Element containing unexpected attribute.</param>
+        /// <param name="attribute">The unexpected attribute.</param>
+        public void UnexpectedAttribute(XElement element, XAttribute attribute)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(element);
+            Common.UnexpectedAttribute(sourceLineNumbers, attribute);
+        }
+
+        /// <summary>
+        /// Display an unexepected element error.
+        /// </summary>
+        /// <param name="parentElement">The parent element.</param>
+        /// <param name="childElement">The unexpected child element.</param>
+        public void UnexpectedElement(XElement parentElement, XElement childElement)
+        {
+            SourceLineNumber sourceLineNumbers = Preprocessor.GetSourceLineNumbers(childElement);
+
+            this.OnMessage(WixErrors.UnexpectedElement(sourceLineNumbers, parentElement.Name.LocalName, childElement.Name.LocalName));
+        }
+
+        /// <summary>
+        /// Sends a message to the message delegate if there is one.
+        /// </summary>
+        /// <param name="mea">Message event arguments.</param>
+        public void OnMessage(MessageEventArgs e)
+        {
+            Messaging.Instance.OnMessage(e);
+        }
+
+        /// <summary>
+        /// Verifies that the calling assembly version is equal to or newer than the given <paramref name="requiredVersion"/>.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information about the owner element.</param>
+        /// <param name="requiredVersion">The version required of the calling assembly.</param>
+        internal void VerifyRequiredVersion(SourceLineNumber sourceLineNumbers, string requiredVersion)
+        {
+            // an null or empty string means any version will work
+            if (!string.IsNullOrEmpty(requiredVersion))
+            {
+                Assembly caller = Assembly.GetCallingAssembly();
+                AssemblyName name = caller.GetName();
+                FileVersionInfo fv = FileVersionInfo.GetVersionInfo(caller.Location);
+
+                Version versionRequired = new Version(requiredVersion);
+                Version versionCurrent = new Version(fv.FileVersion);
+
+                if (versionRequired > versionCurrent)
+                {
+                    if (this.GetType().Assembly.Equals(caller))
+                    {
+                        this.OnMessage(WixErrors.InsufficientVersion(sourceLineNumbers, versionCurrent, versionRequired));
+                    }
+                    else
+                    {
+                        this.OnMessage(WixErrors.InsufficientVersion(sourceLineNumbers, versionCurrent, versionRequired, name.Name));
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Creates a new section and makes it the active section in the core.
+        /// </summary>
+        /// <param name="id">Unique identifier for the section.</param>
+        /// <param name="type">Type of section to create.</param>
+        /// <param name="codepage">Codepage for the resulting database for this ection.</param>
+        /// <returns>New section.</returns>
+        internal Section CreateActiveSection(string id, SectionType type, int codepage)
+        {
+            this.ActiveSection = this.CreateSection(id, type, codepage);
+
+            this.activeSectionInlinedDirectoryIds = new HashSet<string>();
+            this.activeSectionSimpleReferences = new HashSet<string>();
+
+            return this.ActiveSection;
+        }
+
+        /// <summary>
+        /// Creates a new section.
+        /// </summary>
+        /// <param name="id">Unique identifier for the section.</param>
+        /// <param name="type">Type of section to create.</param>
+        /// <param name="codepage">Codepage for the resulting database for this ection.</param>
+        /// <returns>New section.</returns>
+        internal Section CreateSection(string id, SectionType type, int codepage)
+        {
+            Section newSection = new Section(id, type, codepage);
+            this.intermediate.AddSection(newSection);
+
+            return newSection;
+        }
+
+        /// <summary>
+        /// Creates a WiX complex reference in the active section.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information.</param>
+        /// <param name="parentType">The parent type.</param>
+        /// <param name="parentId">The parent id.</param>
+        /// <param name="parentLanguage">The parent language.</param>
+        /// <param name="childType">The child type.</param>
+        /// <param name="childId">The child id.</param>
+        /// <param name="isPrimary">Whether the child is primary.</param>
+        internal void CreateWixComplexReferenceRow(SourceLineNumber sourceLineNumbers, ComplexReferenceParentType parentType, string parentId, string parentLanguage, ComplexReferenceChildType childType, string childId, bool isPrimary)
+        {
+            if (!this.EncounteredError)
+            {
+                WixComplexReferenceRow wixComplexReferenceRow = (WixComplexReferenceRow)this.CreateRow(sourceLineNumbers, "WixComplexReference");
+                wixComplexReferenceRow.ParentId = parentId;
+                wixComplexReferenceRow.ParentType = parentType;
+                wixComplexReferenceRow.ParentLanguage = parentLanguage;
+                wixComplexReferenceRow.ChildId = childId;
+                wixComplexReferenceRow.ChildType = childType;
+                wixComplexReferenceRow.IsPrimary = isPrimary;
+            }
+        }
+
+        /// <summary>
+        /// Creates WixComplexReference and WixGroup rows in the active section.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information.</param>
+        /// <param name="parentType">The parent type.</param>
+        /// <param name="parentId">The parent id.</param>
+        /// <param name="parentLanguage">The parent language.</param>
+        /// <param name="childType">The child type.</param>
+        /// <param name="childId">The child id.</param>
+        /// <param name="isPrimary">Whether the child is primary.</param>
+        public void CreateComplexReference(SourceLineNumber sourceLineNumbers, ComplexReferenceParentType parentType, string parentId, string parentLanguage, ComplexReferenceChildType childType, string childId, bool isPrimary)
+        {
+            this.CreateWixComplexReferenceRow(sourceLineNumbers, parentType, parentId, parentLanguage, childType, childId, isPrimary);
+            this.CreateWixGroupRow(sourceLineNumbers, parentType, parentId, childType, childId);
+        }
+
+        /// <summary>
+        /// Creates a directory row from a name.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information.</param>
+        /// <param name="id">Optional identifier for the new row.</param>
+        /// <param name="parentId">Optional identifier for the parent row.</param>
+        /// <param name="name">Long name of the directory.</param>
+        /// <param name="shortName">Optional short name of the directory.</param>
+        /// <param name="sourceName">Optional source name for the directory.</param>
+        /// <param name="shortSourceName">Optional short source name for the directory.</param>
+        /// <returns>Identifier for the newly created row.</returns>
+        internal Identifier CreateDirectoryRow(SourceLineNumber sourceLineNumbers, Identifier id, string parentId, string name, string shortName = null, string sourceName = null, string shortSourceName = null)
+        {
+            string defaultDir = null;
+
+            if (name.Equals("SourceDir") || this.IsValidShortFilename(name, false))
+            {
+                defaultDir = name;
+            }
+            else
+            {
+                if (String.IsNullOrEmpty(shortName))
+                {
+                    shortName = this.CreateShortName(name, false, false, "Directory", parentId);
+                }
+
+                defaultDir = String.Concat(shortName, "|", name);
+            }
+
+            if (!String.IsNullOrEmpty(sourceName))
+            {
+                if (this.IsValidShortFilename(sourceName, false))
+                {
+                    defaultDir = String.Concat(defaultDir, ":", sourceName);
+                }
+                else
+                {
+                    if (String.IsNullOrEmpty(shortSourceName))
+                    {
+                        shortSourceName = this.CreateShortName(sourceName, false, false, "Directory", parentId);
+                    }
+
+                    defaultDir = String.Concat(defaultDir, ":", shortSourceName, "|", sourceName);
+                }
+            }
+
+            // For anonymous directories, create the identifier. If this identifier already exists in the
+            // active section, bail so we don't add duplicate anonymous directory rows (which are legal
+            // but bloat the intermediate and ultimately make the linker do "busy work").
+            if (null == id)
+            {
+                id = this.CreateIdentifier("dir", parentId, name, shortName, sourceName, shortSourceName);
+
+                if (!this.activeSectionInlinedDirectoryIds.Add(id.Id))
+                {
+                    return id;
+                }
+            }
+
+            Row row = this.CreateRow(sourceLineNumbers, "Directory", id);
+            row[1] = parentId;
+            row[2] = defaultDir;
+            return id;
+        }
+
+        /// <summary>
+        /// Gets the attribute value as inline directory syntax.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information.</param>
+        /// <param name="attribute">Attribute containing the value to get.</param>
+        /// <param name="resultUsedToCreateReference">Flag indicates whether the inline directory syntax should be processed to create a directory row or to create a directory reference.</param>
+        /// <returns>Inline directory syntax split into array of strings or null if the syntax did not parse.</returns>
+        internal string[] GetAttributeInlineDirectorySyntax(SourceLineNumber sourceLineNumbers, XAttribute attribute, bool resultUsedToCreateReference = false)
+        {
+            string[] result = null;
+            string value = this.GetAttributeValue(sourceLineNumbers, attribute);
+
+            if (!String.IsNullOrEmpty(value))
+            {
+                int pathStartsAt = 0;
+                result = value.Split(new char[] { '\\' }, StringSplitOptions.RemoveEmptyEntries);
+                if (result[0].EndsWith(":", StringComparison.Ordinal))
+                {
+                    string id = result[0].TrimEnd(':');
+                    if (1 == result.Length)
+                    {
+                        this.OnMessage(WixErrors.InlineDirectorySyntaxRequiresPath(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value, id));
+                        return null;
+                    }
+                    else if (!this.IsValidIdentifier(id))
+                    {
+                        this.OnMessage(WixErrors.IllegalIdentifier(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value, id));
+                        return null;
+                    }
+
+                    pathStartsAt = 1;
+                }
+                else if (resultUsedToCreateReference && 1 == result.Length)
+                {
+                    if (value.EndsWith("\\"))
+                    {
+                        if (!this.IsValidLongFilename(result[0]))
+                        {
+                            this.OnMessage(WixErrors.IllegalLongFilename(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value, result[0]));
+                            return null;
+                        }
+                    }
+                    else if (!this.IsValidIdentifier(result[0]))
+                    {
+                        this.OnMessage(WixErrors.IllegalIdentifier(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value, result[0]));
+                        return null;
+                    }
+
+                    return result; // return early to avoid additional checks below.
+                }
+
+                // Check each part of the relative path to ensure that it is a valid directory name.
+                for (int i = pathStartsAt; i < result.Length; ++i)
+                {
+                    if (!this.IsValidLongFilename(result[i]))
+                    {
+                        this.OnMessage(WixErrors.IllegalLongFilename(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value, result[i]));
+                        return null;
+                    }
+                }
+
+                if (1 < result.Length && !value.EndsWith("\\"))
+                {
+                    this.OnMessage(WixWarnings.BackslashTerminateInlineDirectorySyntax(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName, value));
+                }
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Finds a compiler extension by namespace URI.
+        /// </summary>
+        /// <param name="ns">Namespace the extension supports.</param>
+        /// <returns>True if found compiler extension or false if nothing matches namespace URI.</returns>
+        private bool TryFindExtension(XNamespace ns, out ICompilerExtension extension)
+        {
+            return this.extensions.TryGetValue(ns, out extension);
+        }
+
+        private static string CreateValueList(ValueListKind kind, IEnumerable<string> values)
+        {
+            // Ideally, we could denote the list kind (and the list itself) directly in the
+            // message XML, and detect and expand in the MessageHandler.GenerateMessageString()
+            // method.  Doing so would make vararg-style messages much easier, but impacts
+            // every single message we format.  For now, callers just have to know when a
+            // message takes a list of values in a single string argument, the caller will
+            // have to do the expansion themselves.  (And, unfortunately, hard-code the knowledge
+            // that the list is an 'and' or 'or' list.)
+
+            // For a localizable solution, we need to be able to get the list format string
+            // from resources. We aren't currently localized right now, so the values are
+            // just hard-coded.
+            const string valueFormat = "'{0}'";
+            const string valueSeparator = ", ";
+            string terminalTerm = String.Empty;
+
+            switch (kind)
+            {
+                case ValueListKind.None:
+                    terminalTerm = "";
+                    break;
+                case ValueListKind.And:
+                    terminalTerm = "and ";
+                    break;
+                case ValueListKind.Or:
+                    terminalTerm = "or ";
+                    break;
+            }
+
+            StringBuilder list = new StringBuilder();
+
+            // This weird construction helps us determine when we're adding the last value
+            // to the list.  Instead of adding them as we encounter them, we cache the current
+            // value and append the *previous* one.
+            string previousValue = null;
+            bool haveValues = false;
+            foreach (string value in values)
+            {
+                if (null != previousValue)
+                {
+                    if (haveValues)
+                    {
+                        list.Append(valueSeparator);
+                    }
+                    list.AppendFormat(valueFormat, previousValue);
+                    haveValues = true;
+                }
+
+                previousValue = value;
+            }
+
+            // If we have no previous value, that means that the list contained no values, and
+            // something has gone very wrong.
+            Debug.Assert(null != previousValue);
+            if (null != previousValue)
+            {
+                if (haveValues)
+                {
+                    list.Append(valueSeparator);
+                    list.Append(terminalTerm);
+                }
+                list.AppendFormat(valueFormat, previousValue);
+                haveValues = true;
+            }
+
+            return list.ToString();
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Converter.cs b/src/WixToolset.Core/Converter.cs
new file mode 100644
index 00000000..6ae2f984
--- /dev/null
+++ b/src/WixToolset.Core/Converter.cs
@@ -0,0 +1,614 @@
+// 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
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.IO;
+    using System.Linq;
+    using System.Xml;
+    using System.Xml.Linq;
+    using WixToolset.Data;
+
+    /// <summary>
+    /// WiX source code converter.
+    /// </summary>
+    public class Converter
+    {
+        private const string XDocumentNewLine = "\n"; // XDocument normlizes "\r\n" to just "\n".
+        private static readonly XNamespace WixNamespace = "http://wixtoolset.org/schemas/v4/wxs";
+
+        private static readonly XName FileElementName = WixNamespace + "File";
+        private static readonly XName ExePackageElementName = WixNamespace + "ExePackage";
+        private static readonly XName MsiPackageElementName = WixNamespace + "MsiPackage";
+        private static readonly XName MspPackageElementName = WixNamespace + "MspPackage";
+        private static readonly XName MsuPackageElementName = WixNamespace + "MsuPackage";
+        private static readonly XName PayloadElementName = WixNamespace + "Payload";
+        private static readonly XName WixElementWithoutNamespaceName = XNamespace.None + "Wix";
+
+        private static readonly Dictionary<string, XNamespace> OldToNewNamespaceMapping = new Dictionary<string, XNamespace>()
+        {
+            { "http://schemas.microsoft.com/wix/BalExtension", "http://wixtoolset.org/schemas/v4/wxs/bal" },
+            { "http://schemas.microsoft.com/wix/ComPlusExtension", "http://wixtoolset.org/schemas/v4/wxs/complus" },
+            { "http://schemas.microsoft.com/wix/DependencyExtension", "http://wixtoolset.org/schemas/v4/wxs/dependency" },
+            { "http://schemas.microsoft.com/wix/DifxAppExtension", "http://wixtoolset.org/schemas/v4/wxs/difxapp" },
+            { "http://schemas.microsoft.com/wix/FirewallExtension", "http://wixtoolset.org/schemas/v4/wxs/firewall" },
+            { "http://schemas.microsoft.com/wix/GamingExtension", "http://wixtoolset.org/schemas/v4/wxs/gaming" },
+            { "http://schemas.microsoft.com/wix/IIsExtension", "http://wixtoolset.org/schemas/v4/wxs/iis" },
+            { "http://schemas.microsoft.com/wix/MsmqExtension", "http://wixtoolset.org/schemas/v4/wxs/msmq" },
+            { "http://schemas.microsoft.com/wix/NetFxExtension", "http://wixtoolset.org/schemas/v4/wxs/netfx" },
+            { "http://schemas.microsoft.com/wix/PSExtension", "http://wixtoolset.org/schemas/v4/wxs/powershell" },
+            { "http://schemas.microsoft.com/wix/SqlExtension", "http://wixtoolset.org/schemas/v4/wxs/sql" },
+            { "http://schemas.microsoft.com/wix/TagExtension", "http://wixtoolset.org/schemas/v4/wxs/tag" },
+            { "http://schemas.microsoft.com/wix/UtilExtension", "http://wixtoolset.org/schemas/v4/wxs/util" },
+            { "http://schemas.microsoft.com/wix/VSExtension", "http://wixtoolset.org/schemas/v4/wxs/vs" },
+            { "http://wixtoolset.org/schemas/thmutil/2010", "http://wixtoolset.org/schemas/v4/thmutil" },
+            { "http://schemas.microsoft.com/wix/2009/Lux", "http://wixtoolset.org/schemas/v4/lux" },
+            { "http://schemas.microsoft.com/wix/2006/wi", "http://wixtoolset.org/schemas/v4/wxs" },
+            { "http://schemas.microsoft.com/wix/2006/localization", "http://wixtoolset.org/schemas/v4/wxl" },
+            { "http://schemas.microsoft.com/wix/2006/libraries", "http://wixtoolset.org/schemas/v4/wixlib" },
+            { "http://schemas.microsoft.com/wix/2006/objects", "http://wixtoolset.org/schemas/v4/wixobj" },
+            { "http://schemas.microsoft.com/wix/2006/outputs", "http://wixtoolset.org/schemas/v4/wixout" },
+            { "http://schemas.microsoft.com/wix/2007/pdbs", "http://wixtoolset.org/schemas/v4/wixpdb" },
+            { "http://schemas.microsoft.com/wix/2003/04/actions", "http://wixtoolset.org/schemas/v4/wi/actions" },
+            { "http://schemas.microsoft.com/wix/2006/tables", "http://wixtoolset.org/schemas/v4/wi/tables" },
+            { "http://schemas.microsoft.com/wix/2006/WixUnit", "http://wixtoolset.org/schemas/v4/wixunit" },
+        };
+
+        private Dictionary<XName, Action<XElement>> ConvertElementMapping;
+
+        /// <summary>
+        /// Instantiate a new Converter class.
+        /// </summary>
+        /// <param name="indentationAmount">Indentation value to use when validating leading whitespace.</param>
+        /// <param name="errorsAsWarnings">Test errors to display as warnings.</param>
+        /// <param name="ignoreErrors">Test errors to ignore.</param>
+        public Converter(int indentationAmount, IEnumerable<string> errorsAsWarnings = null, IEnumerable<string> ignoreErrors = null)
+        {
+            this.ConvertElementMapping = new Dictionary<XName, Action<XElement>>()
+            {
+                { FileElementName, this.ConvertFileElement },
+                { ExePackageElementName, this.ConvertSuppressSignatureValidation },
+                { MsiPackageElementName, this.ConvertSuppressSignatureValidation },
+                { MspPackageElementName, this.ConvertSuppressSignatureValidation },
+                { MsuPackageElementName, this.ConvertSuppressSignatureValidation },
+                { PayloadElementName, this.ConvertSuppressSignatureValidation },
+                { WixElementWithoutNamespaceName, this.ConvertWixElementWithoutNamespace },
+            };
+
+            this.IndentationAmount = indentationAmount;
+
+            this.ErrorsAsWarnings = new HashSet<ConverterTestType>(this.YieldConverterTypes(errorsAsWarnings));
+
+            this.IgnoreErrors = new HashSet<ConverterTestType>(this.YieldConverterTypes(ignoreErrors));
+        }
+
+        private int Errors { get; set; }
+
+        private HashSet<ConverterTestType> ErrorsAsWarnings { get; set; }
+
+        private HashSet<ConverterTestType> IgnoreErrors { get; set; }
+
+        private int IndentationAmount { get; set; }
+
+        private string SourceFile { get; set; }
+
+        /// <summary>
+        /// Convert a file.
+        /// </summary>
+        /// <param name="sourceFile">The file to convert.</param>
+        /// <param name="saveConvertedFile">Option to save the converted errors that are found.</param>
+        /// <returns>The number of errors found.</returns>
+        public int ConvertFile(string sourceFile, bool saveConvertedFile)
+        {
+            XDocument document;
+
+            // Set the instance info.
+            this.Errors = 0;
+            this.SourceFile = sourceFile;
+
+            try
+            {
+                document = XDocument.Load(this.SourceFile, LoadOptions.PreserveWhitespace | LoadOptions.SetLineInfo);
+            }
+            catch (XmlException e)
+            {
+                this.OnError(ConverterTestType.XmlException, (XObject)null, "The xml is invalid.  Detail: '{0}'", e.Message);
+
+                return this.Errors;
+            }
+
+            this.ConvertDocument(document);
+
+            // Fix errors if requested and necessary.
+            if (saveConvertedFile && 0 < this.Errors)
+            {
+                try
+                {
+                    using (StreamWriter writer = File.CreateText(this.SourceFile))
+                    {
+                        document.Save(writer, SaveOptions.DisableFormatting | SaveOptions.OmitDuplicateNamespaces);
+                    }
+                }
+                catch (UnauthorizedAccessException)
+                {
+                    this.OnError(ConverterTestType.UnauthorizedAccessException, (XObject)null, "Could not write to file.");
+                }
+            }
+
+            return this.Errors;
+        }
+
+        /// <summary>
+        /// Convert a document.
+        /// </summary>
+        /// <param name="document">The document to convert.</param>
+        /// <returns>The number of errors found.</returns>
+        public int ConvertDocument(XDocument document)
+        {
+            XDeclaration declaration = document.Declaration;
+
+            // Convert the declaration.
+            if (null != declaration)
+            {
+                if (!String.Equals("utf-8", declaration.Encoding, StringComparison.OrdinalIgnoreCase))
+                {
+                    if (this.OnError(ConverterTestType.DeclarationEncodingWrong, document.Root, "The XML declaration encoding is not properly set to 'utf-8'."))
+                    {
+                        declaration.Encoding = "utf-8";
+                    }
+                }
+            }
+            else // missing declaration
+            {
+                if (this.OnError(ConverterTestType.DeclarationMissing, (XNode)null, "This file is missing an XML declaration on the first line."))
+                {
+                    document.Declaration = new XDeclaration("1.0", "utf-8", null);
+                    document.Root.AddBeforeSelf(new XText(XDocumentNewLine));
+                }
+            }
+
+            // Start converting the nodes at the top.
+            this.ConvertNode(document.Root, 0);
+
+            return this.Errors;
+        }
+
+        /// <summary>
+        /// Convert a single xml node.
+        /// </summary>
+        /// <param name="node">The node to convert.</param>
+        /// <param name="level">The depth level of the node.</param>
+        /// <returns>The converted node.</returns>
+        private void ConvertNode(XNode node, int level)
+        {
+            // Convert this node's whitespace.
+            if ((XmlNodeType.Comment == node.NodeType && 0 > ((XComment)node).Value.IndexOf(XDocumentNewLine, StringComparison.Ordinal)) ||
+                XmlNodeType.CDATA == node.NodeType || XmlNodeType.Element == node.NodeType || XmlNodeType.ProcessingInstruction == node.NodeType)
+            {
+                this.ConvertWhitespace(node, level);
+            }
+
+            // Convert this node if it is an element.
+            XElement element = node as XElement;
+
+            if (null != element)
+            {
+                this.ConvertElement(element);
+
+                // Convert all children of this element.
+                IEnumerable<XNode> children = element.Nodes().ToList();
+
+                foreach (XNode child in children)
+                {
+                    this.ConvertNode(child, level + 1);
+                }
+            }
+        }
+
+        private void ConvertElement(XElement element)
+        {
+            // Gather any deprecated namespaces, then update this element tree based on those deprecations.
+            Dictionary<XNamespace, XNamespace> deprecatedToUpdatedNamespaces = new Dictionary<XNamespace, XNamespace>();
+
+            foreach (XAttribute declaration in element.Attributes().Where(a => a.IsNamespaceDeclaration))
+            {
+                XNamespace ns;
+
+                if (Converter.OldToNewNamespaceMapping.TryGetValue(declaration.Value, out ns))
+                {
+                    if (this.OnError(ConverterTestType.XmlnsValueWrong, declaration, "The namespace '{0}' is out of date.  It must be '{1}'.", declaration.Value, ns.NamespaceName))
+                    {
+                        deprecatedToUpdatedNamespaces.Add(declaration.Value, ns);
+                    }
+                }
+            }
+
+            if (deprecatedToUpdatedNamespaces.Any())
+            {
+                Converter.UpdateElementsWithDeprecatedNamespaces(element.DescendantsAndSelf(), deprecatedToUpdatedNamespaces);
+            }
+
+            // Convert the node in much greater detail.
+            Action<XElement> convert;
+
+            if (this.ConvertElementMapping.TryGetValue(element.Name, out convert))
+            {
+                convert(element);
+            }
+        }
+
+        private void ConvertFileElement(XElement element)
+        {
+            if (null == element.Attribute("Id"))
+            {
+                XAttribute attribute = element.Attribute("Name");
+
+                if (null == attribute)
+                {
+                    attribute = element.Attribute("Source");
+                }
+
+                if (null != attribute)
+                {
+                    string name = Path.GetFileName(attribute.Value);
+
+                    if (this.OnError(ConverterTestType.AssignAnonymousFileId, element, "The file id is being updated to '{0}' to ensure it remains the same as the default", name))
+                    {
+                        IEnumerable<XAttribute> attributes = element.Attributes().ToList();
+                        element.RemoveAttributes();
+                        element.Add(new XAttribute("Id", Common.GetIdentifierFromName(name)));
+                        element.Add(attributes);
+                    }
+                }
+            }
+        }
+
+        private void ConvertSuppressSignatureValidation(XElement element)
+        {
+            XAttribute suppressSignatureValidation = element.Attribute("SuppressSignatureValidation");
+
+            if (null != suppressSignatureValidation)
+            {
+                if (this.OnError(ConverterTestType.SuppressSignatureValidationDeprecated, element, "The chain package element contains deprecated '{0}' attribute. Use the 'EnableSignatureValidation' instead.", suppressSignatureValidation))
+                {
+                    if ("no" == suppressSignatureValidation.Value)
+                    {
+                        element.Add(new XAttribute("EnableSignatureValidation", "yes"));
+                    }
+                }
+
+                suppressSignatureValidation.Remove();
+            }
+        }
+
+        /// <summary>
+        /// Converts a Wix element.
+        /// </summary>
+        /// <param name="element">The Wix element to convert.</param>
+        /// <returns>The converted element.</returns>
+        private void ConvertWixElementWithoutNamespace(XElement element)
+        {
+            if (this.OnError(ConverterTestType.XmlnsMissing, element, "The xmlns attribute is missing.  It must be present with a value of '{0}'.", WixNamespace.NamespaceName))
+            {
+                element.Name = WixNamespace.GetName(element.Name.LocalName);
+
+                element.Add(new XAttribute("xmlns", WixNamespace.NamespaceName)); // set the default namespace.
+
+                foreach (XElement elementWithoutNamespace in element.Elements().Where(e => XNamespace.None == e.Name.Namespace))
+                {
+                    elementWithoutNamespace.Name = WixNamespace.GetName(elementWithoutNamespace.Name.LocalName);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Convert the whitespace adjacent to a node.
+        /// </summary>
+        /// <param name="node">The node to convert.</param>
+        /// <param name="level">The depth level of the node.</param>
+        private void ConvertWhitespace(XNode node, int level)
+        {
+            // Fix the whitespace before this node.
+            XText whitespace = node.PreviousNode as XText;
+
+            if (null != whitespace)
+            {
+                if (XmlNodeType.CDATA == node.NodeType)
+                {
+                    if (this.OnError(ConverterTestType.WhitespacePrecedingCDATAWrong, node, "There should be no whitespace preceding a CDATA node."))
+                    {
+                        whitespace.Remove();
+                    }
+                }
+                else
+                {
+                    if (!Converter.IsLegalWhitespace(this.IndentationAmount, level, whitespace.Value))
+                    {
+                        if (this.OnError(ConverterTestType.WhitespacePrecedingNodeWrong, node, "The whitespace preceding this node is incorrect."))
+                        {
+                            Converter.FixWhitespace(this.IndentationAmount, level, whitespace);
+                        }
+                    }
+                }
+            }
+
+            // Fix the whitespace after CDATA nodes.
+            XCData cdata = node as XCData;
+
+            if (null != cdata)
+            {
+                whitespace = cdata.NextNode as XText;
+
+                if (null != whitespace)
+                {
+                    if (this.OnError(ConverterTestType.WhitespaceFollowingCDATAWrong, node, "There should be no whitespace following a CDATA node."))
+                    {
+                        whitespace.Remove();
+                    }
+                }
+            }
+            else
+            {
+                // Fix the whitespace inside and after this node (except for Error which may contain just whitespace).
+                XElement element = node as XElement;
+
+                if (null != element && "Error" != element.Name.LocalName)
+                {
+                    if (!element.HasElements && !element.IsEmpty && String.IsNullOrEmpty(element.Value.Trim()))
+                    {
+                        if (this.OnError(ConverterTestType.NotEmptyElement, element, "This should be an empty element since it contains nothing but whitespace."))
+                        {
+                            element.RemoveNodes();
+                        }
+                    }
+
+                    whitespace = node.NextNode as XText;
+
+                    if (null != whitespace)
+                    {
+                        if (!Converter.IsLegalWhitespace(this.IndentationAmount, level - 1, whitespace.Value))
+                        {
+                            if (this.OnError(ConverterTestType.WhitespacePrecedingEndElementWrong, whitespace, "The whitespace preceding this end element is incorrect."))
+                            {
+                                Converter.FixWhitespace(this.IndentationAmount, level - 1, whitespace);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        private IEnumerable<ConverterTestType> YieldConverterTypes(IEnumerable<string> types)
+        {
+            if (null != types)
+            {
+                foreach (string type in types)
+                {
+                    ConverterTestType itt;
+
+                    if (Enum.TryParse<ConverterTestType>(type, true, out itt))
+                    {
+                        yield return itt;
+                    }
+                    else // not a known ConverterTestType
+                    {
+                        this.OnError(ConverterTestType.ConverterTestTypeUnknown, (XObject)null, "Unknown error type: '{0}'.", type);
+                    }
+                }
+            }
+        }
+
+        private static void UpdateElementsWithDeprecatedNamespaces(IEnumerable<XElement> elements, Dictionary<XNamespace, XNamespace> deprecatedToUpdatedNamespaces)
+        {
+            foreach (XElement element in elements)
+            {
+                XNamespace ns;
+
+                if (deprecatedToUpdatedNamespaces.TryGetValue(element.Name.Namespace, out ns))
+                {
+                    element.Name = ns.GetName(element.Name.LocalName);
+                }
+
+                // Remove all the attributes and add them back to with their namespace updated (as necessary).
+                IEnumerable<XAttribute> attributes = element.Attributes().ToList();
+                element.RemoveAttributes();
+
+                foreach (XAttribute attribute in attributes)
+                {
+                    XAttribute convertedAttribute = attribute;
+
+                    if (attribute.IsNamespaceDeclaration)
+                    {
+                        if (deprecatedToUpdatedNamespaces.TryGetValue(attribute.Value, out ns))
+                        {
+                            convertedAttribute = ("xmlns" == attribute.Name.LocalName) ? new XAttribute(attribute.Name.LocalName, ns.NamespaceName) : new XAttribute(XNamespace.Xmlns + attribute.Name.LocalName, ns.NamespaceName);
+                        }
+                    }
+                    else if (deprecatedToUpdatedNamespaces.TryGetValue(attribute.Name.Namespace, out ns))
+                    {
+                        convertedAttribute = new XAttribute(ns.GetName(attribute.Name.LocalName), attribute.Value);
+                    }
+
+                    element.Add(convertedAttribute);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Determine if the whitespace preceding a node is appropriate for its depth level.
+        /// </summary>
+        /// <param name="indentationAmount">Indentation value to use when validating leading whitespace.</param>
+        /// <param name="level">The depth level that should match this whitespace.</param>
+        /// <param name="whitespace">The whitespace to validate.</param>
+        /// <returns>true if the whitespace is legal; false otherwise.</returns>
+        private static bool IsLegalWhitespace(int indentationAmount, int level, string whitespace)
+        {
+            // strip off leading newlines; there can be an arbitrary number of these
+            while (whitespace.StartsWith(XDocumentNewLine, StringComparison.Ordinal))
+            {
+                whitespace = whitespace.Substring(XDocumentNewLine.Length);
+            }
+
+            // check the length
+            if (whitespace.Length != level * indentationAmount)
+            {
+                return false;
+            }
+
+            // check the spaces
+            foreach (char character in whitespace)
+            {
+                if (' ' != character)
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Fix the whitespace in a Whitespace node.
+        /// </summary>
+        /// <param name="indentationAmount">Indentation value to use when validating leading whitespace.</param>
+        /// <param name="level">The depth level of the desired whitespace.</param>
+        /// <param name="whitespace">The whitespace node to fix.</param>
+        private static void FixWhitespace(int indentationAmount, int level, XText whitespace)
+        {
+            int newLineCount = 0;
+
+            for (int i = 0; i + 1 < whitespace.Value.Length; ++i)
+            {
+                if (XDocumentNewLine == whitespace.Value.Substring(i, 2))
+                {
+                    ++i; // skip an extra character
+                    ++newLineCount;
+                }
+            }
+
+            if (0 == newLineCount)
+            {
+                newLineCount = 1;
+            }
+
+            // reset the whitespace value
+            whitespace.Value = String.Empty;
+
+            // add the correct number of newlines
+            for (int i = 0; i < newLineCount; ++i)
+            {
+                whitespace.Value = String.Concat(whitespace.Value, XDocumentNewLine);
+            }
+
+            // add the correct number of spaces based on configured indentation amount
+            whitespace.Value = String.Concat(whitespace.Value, new string(' ', level * indentationAmount));
+        }
+
+        /// <summary>
+        /// Output an error message to the console.
+        /// </summary>
+        /// <param name="converterTestType">The type of converter test.</param>
+        /// <param name="node">The node that caused the error.</param>
+        /// <param name="message">Detailed error message.</param>
+        /// <param name="args">Additional formatted string arguments.</param>
+        /// <returns>Returns true indicating that action should be taken on this error, and false if it should be ignored.</returns>
+        private bool OnError(ConverterTestType converterTestType, XObject node, string message, params object[] args)
+        {
+            if (this.IgnoreErrors.Contains(converterTestType)) // ignore the error
+            {
+                return false;
+            }
+
+            // Increase the error count.
+            this.Errors++;
+
+            SourceLineNumber sourceLine = (null == node) ? new SourceLineNumber(this.SourceFile ?? "wixcop.exe") : new SourceLineNumber(this.SourceFile, ((IXmlLineInfo)node).LineNumber);
+            bool warning = this.ErrorsAsWarnings.Contains(converterTestType);
+            string display = String.Format(CultureInfo.CurrentCulture, message, args);
+
+            WixGenericMessageEventArgs ea = new WixGenericMessageEventArgs(sourceLine, (int)converterTestType, warning ? MessageLevel.Warning : MessageLevel.Error, "{0} ({1})", display, converterTestType.ToString());
+
+            Messaging.Instance.OnMessage(ea);
+
+            return true;
+        }
+
+        /// <summary>
+        /// Converter test types.  These are used to condition error messages down to warnings.
+        /// </summary>
+        private enum ConverterTestType
+        {
+            /// <summary>
+            /// Internal-only: displayed when a string cannot be converted to an ConverterTestType.
+            /// </summary>
+            ConverterTestTypeUnknown,
+
+            /// <summary>
+            /// Displayed when an XML loading exception has occurred.
+            /// </summary>
+            XmlException,
+
+            /// <summary>
+            /// Displayed when a file cannot be accessed; typically when trying to save back a fixed file.
+            /// </summary>
+            UnauthorizedAccessException,
+
+            /// <summary>
+            /// Displayed when the encoding attribute in the XML declaration is not 'UTF-8'.
+            /// </summary>
+            DeclarationEncodingWrong,
+
+            /// <summary>
+            /// Displayed when the XML declaration is missing from the source file.
+            /// </summary>
+            DeclarationMissing,
+
+            /// <summary>
+            /// Displayed when the whitespace preceding a CDATA node is wrong.
+            /// </summary>
+            WhitespacePrecedingCDATAWrong,
+
+            /// <summary>
+            /// Displayed when the whitespace preceding a node is wrong.
+            /// </summary>
+            WhitespacePrecedingNodeWrong,
+
+            /// <summary>
+            /// Displayed when an element is not empty as it should be.
+            /// </summary>
+            NotEmptyElement,
+
+            /// <summary>
+            /// Displayed when the whitespace following a CDATA node is wrong.
+            /// </summary>
+            WhitespaceFollowingCDATAWrong,
+
+            /// <summary>
+            /// Displayed when the whitespace preceding an end element is wrong.
+            /// </summary>
+            WhitespacePrecedingEndElementWrong,
+
+            /// <summary>
+            /// Displayed when the xmlns attribute is missing from the document element.
+            /// </summary>
+            XmlnsMissing,
+
+            /// <summary>
+            /// Displayed when the xmlns attribute on the document element is wrong.
+            /// </summary>
+            XmlnsValueWrong,
+
+            /// <summary>
+            /// Assign an identifier to a File element when on Id attribute is specified.
+            /// </summary>
+            AssignAnonymousFileId,
+
+            /// <summary>
+            /// SuppressSignatureValidation attribute is deprecated and replaced with EnableSignatureValidation.
+            /// </summary>
+            SuppressSignatureValidationDeprecated,
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Data/messages.xml b/src/WixToolset.Core/Data/messages.xml
new file mode 100644
index 00000000..edc98147
--- /dev/null
+++ b/src/WixToolset.Core/Data/messages.xml
@@ -0,0 +1,4010 @@
+<?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. -->
+
+
+<Messages Namespace="WixToolset" Resources="Core.Data.Messages" xmlns="http://schemas.microsoft.com/genmsgs/2004/07/messages">
+    <Class Name="WixErrors" ContainerName="WixErrorEventArgs" BaseContainerName="MessageEventArgs" Level="Error">
+        <Message Id="UnexpectedException" Number="1" SourceLineNumbers="no">
+            <Instance>
+                {0}&#13;&#10;&#13;&#10;Exception Type: {1}&#13;&#10;&#13;&#10;Stack Trace:&#13;&#10;{2}
+                <Parameter Type="System.String" Name="message" />
+                <Parameter Type="System.String" Name="type" />
+                <Parameter Type="System.String" Name="stackTrace" />
+            </Instance>
+        </Message>
+        <Message Id="UnexpectedAttribute" Number="4">
+            <Instance>
+                The {0} element contains an unexpected attribute '{1}'.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+            </Instance>
+        </Message>
+        <Message Id="UnexpectedElement" Number="5">
+            <Instance>
+                The {0} element contains an unexpected child element '{1}'.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="childElementName" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalEmptyAttributeValue" Number="6">
+            <Instance>
+                The {0}/@{1} attribute's value cannot be an empty string. If a value is not required, simply remove the entire attribute.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+            </Instance>
+            <Instance>
+                The {0}/@{1} attribute's value cannot be an empty string.  To use the default value "{2}", simply remove the entire attribute.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="defaultValue" />
+            </Instance>
+        </Message>
+        <Message Id="InsufficientVersion" Number="7">
+            <Instance>
+                The current version of the toolset is {0}, but version {1} is required.
+                <Parameter Type="System.Version" Name="currentVersion" />
+                <Parameter Type="System.Version" Name="requiredVersion" />
+            </Instance>
+            <Instance>
+                The current version of the extension '{2}' is {0}, but version {1} is required.
+                <Parameter Type="System.Version" Name="currentVersion" />
+                <Parameter Type="System.Version" Name="requiredVersion" />
+                <Parameter Type="System.String" Name="extension" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalIntegerValue" Number="8">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is not a legal integer value.  Legal integer values are from -2,147,483,648 to 2,147,483,647.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalGuidValue" Number="9">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is not a legal guid value.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+            </Instance>
+        </Message>
+        <Message Id="ExpectedAttribute" Number="10">
+            <Instance>
+                The {0}/@{1} attribute was not found; it is required.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+            </Instance>
+            <Instance>
+                The {0} element must have a value for exactly one of the {1} or {2} attributes.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attribute1Name" />
+                <Parameter Type="System.String" Name="attribute2Name" />
+                <Parameter Type="System.Boolean" Name="eitherOr" />
+            </Instance>
+            <Instance>
+                The {0}/@{1} attribute was not found; it is required when attribute {2} is specified.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="otherAttributeName" />
+            </Instance>
+            <Instance>
+                The {0}/@{1} attribute was not found; it is required when attribute {2} has a value of '{3}'.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="otherAttributeName" />
+                <Parameter Type="System.String" Name="otherAttributeValue" />
+            </Instance>
+            <Instance>
+                The {0}/@{1} attribute was not found; it is required unless the attribute {2} has a value of '{3}'.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="otherAttributeName" />
+                <Parameter Type="System.String" Name="otherAttributeValue" />
+                <Parameter Type="System.Boolean" Name="otherAttributeValueUnless" />
+            </Instance>
+        </Message>
+        <Message Id="SecurePropertyNotUppercase" Number="11">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', cannot contain lowercase characters.  Since this is a secure property, it must also be a public property.  This means the Property/@Id value must be completely uppercase.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="propertyId" />
+            </Instance>
+        </Message>
+        <Message Id="SearchPropertyNotUppercase" Number="12">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', cannot contain lowercase characters.  Since this is a search property, it must also be a public property.  This means the Property/@Id value must be completely uppercase.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+            </Instance>
+        </Message>
+        <Message Id="StreamNameTooLong" Number="13">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is {3} characters long.  This is too long because it will be used to create a stream name.  It cannot be more than than {4} characters long.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+                <Parameter Type="System.Int32" Name="length" />
+                <Parameter Type="System.Int32" Name="maximumLength" />
+            </Instance>
+            <Instance>
+                The binary value in table '{0}' will be stored with a stream name, '{1}', that is {2} characters long.  This is too long because the maximum allowed length for a stream name is 62 characters long.  Since the stream name is created by concatenating the table name and values of the primary key for a row (delimited by periods), this error can be resolved by shortening a value that is part of the primary key.
+                <Parameter Type="System.String" Name="tableName" />
+                <Parameter Type="System.String" Name="streamName" />
+                <Parameter Type="System.Int32" Name="streamLength" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalIdentifier" Number="14">
+            <Instance>
+                The {0} element's value, '{1}', is not a legal identifier. Identifiers may contain ASCII characters A-Z, a-z, digits, underscores (_), or periods (.). Every identifier must begin with either a letter or an underscore.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="value" />
+            </Instance>
+            <Instance>
+                The {0}/@{1} attribute's value is not a legal identifier. Identifiers may contain ASCII characters A-Z, a-z, digits, underscores (_), or periods (.). Every identifier must begin with either a letter or an underscore.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.Int32" Name="disambiguator" />
+            </Instance>
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is not a legal identifier. Identifiers may contain ASCII characters A-Z, a-z, digits, underscores (_), or periods (.). Every identifier must begin with either a letter or an underscore.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+            </Instance>
+            <Instance>
+                The {0}/@{1} attribute's value '{2}' contains an illegal identifier '{3}'. Identifiers may contain ASCII characters A-Z, a-z, digits, underscores (_), or periods (.). Every identifier must begin with either a letter or an underscore.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+                <Parameter Type="System.String" Name="identifier" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalYesNoValue" Number="15">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is not a legal yes/no value.  The only legal values are 'no' and 'yes'.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+            </Instance>
+        </Message>
+        <Message Id="CabCreationFailed" Number="16" SourceLineNumbers="no">
+            <Instance>
+                Failed to create cab '{0}' while compressing file '{1}' with error 0x{2:X8}.
+                <Parameter Type="System.String" Name="cabName" />
+                <Parameter Type="System.String" Name="fileName" />
+                <Parameter Type="System.Int32" Name="error" />
+            </Instance>
+            <Instance>
+                Failed to create cab '{0}' with error 0x{1:X8}.
+                <Parameter Type="System.String" Name="cabName" />
+                <Parameter Type="System.Int32" Name="error" />
+            </Instance>
+        </Message>
+        <Message Id="CabExtractionFailed" Number="17" SourceLineNumbers="no">
+            <Instance>
+                Failed to extract cab '{0}' to directory '{1}'.  This is most likely due to a lack of available disk space on the destination drive.
+                <Parameter Type="System.String" Name="cabName" />
+                <Parameter Type="System.String" Name="directoryName" />
+            </Instance>
+            <Instance>
+                Failed to extract cab '{0}' from merge module '{1}' to directory '{2}'.  This is most likely due to a lack of available disk space on the destination drive.
+                <Parameter Type="System.String" Name="cabName" />
+                <Parameter Type="System.String" Name="mergeModulePath" />
+                <Parameter Type="System.String" Name="directoryName" />
+            </Instance>
+        </Message>
+        <Message Id="AppIdIncompatibleAdvertiseState" Number="18">
+            <Instance>
+                The {0}/@(1) attribute's value, '{2}' does not match the advertise state on its parent element: '{3}'.  (Note: AppIds nested under Fragment, Module, or Product elements must be advertised.)
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+                <Parameter Type="System.String" Name="parentValue" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalAttributeWhenAdvertised" Number="19">
+            <Instance>
+                The {0}/@{1} attribute cannot be specified because the element is advertised.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+            </Instance>
+        </Message>
+        <Message Id="ConditionExpected" Number="20">
+            <Instance>
+                The {0} element's inner text cannot be an empty string or completely whitespace.  If you don't want a condition, then simply remove the entire {0} element.
+                <Parameter Type="System.String" Name="elementName" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalAttributeValue" Number="21">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is not one of the legal options: '{3}'.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+                <Parameter Type="System.String" Name="legalValue1" />
+            </Instance>
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is not one of the legal options: '{3}', or '{4}'.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+                <Parameter Type="System.String" Name="legalValue1" />
+                <Parameter Type="System.String" Name="legalValue2" />
+            </Instance>
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is not one of the legal options: '{3}', '{4}', or '{5}'.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+                <Parameter Type="System.String" Name="legalValue1" />
+                <Parameter Type="System.String" Name="legalValue2" />
+                <Parameter Type="System.String" Name="legalValue3" />
+            </Instance>
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is not one of the legal options: '{3}', '{4}', '{5}', or '{6}'.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+                <Parameter Type="System.String" Name="legalValue1" />
+                <Parameter Type="System.String" Name="legalValue2" />
+                <Parameter Type="System.String" Name="legalValue3" />
+                <Parameter Type="System.String" Name="legalValue4" />
+            </Instance>
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is not one of the legal options: '{3}', '{4}', '{5}', '{6}', or '{7}'.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+                <Parameter Type="System.String" Name="legalValue1" />
+                <Parameter Type="System.String" Name="legalValue2" />
+                <Parameter Type="System.String" Name="legalValue3" />
+                <Parameter Type="System.String" Name="legalValue4" />
+                <Parameter Type="System.String" Name="legalValue5" />
+            </Instance>
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is not one of the legal options: '{3}', '{4}', '{5}', '{6}', '{7}', or '{8}'.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+                <Parameter Type="System.String" Name="legalValue1" />
+                <Parameter Type="System.String" Name="legalValue2" />
+                <Parameter Type="System.String" Name="legalValue3" />
+                <Parameter Type="System.String" Name="legalValue4" />
+                <Parameter Type="System.String" Name="legalValue5" />
+                <Parameter Type="System.String" Name="legalValue6" />
+            </Instance>
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is not one of the legal options: '{3}', '{4}', '{5}', '{6}', '{7}', '{8}', or '{9}'.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+                <Parameter Type="System.String" Name="legalValue1" />
+                <Parameter Type="System.String" Name="legalValue2" />
+                <Parameter Type="System.String" Name="legalValue3" />
+                <Parameter Type="System.String" Name="legalValue4" />
+                <Parameter Type="System.String" Name="legalValue5" />
+                <Parameter Type="System.String" Name="legalValue6" />
+                <Parameter Type="System.String" Name="legalValue7" />
+            </Instance>
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is not one of the legal options: '{3}', '{4}', '{5}', '{6}', '{7}', '{8}', '{9}', or '{10}'.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+                <Parameter Type="System.String" Name="legalValue1" />
+                <Parameter Type="System.String" Name="legalValue2" />
+                <Parameter Type="System.String" Name="legalValue3" />
+                <Parameter Type="System.String" Name="legalValue4" />
+                <Parameter Type="System.String" Name="legalValue5" />
+                <Parameter Type="System.String" Name="legalValue6" />
+                <Parameter Type="System.String" Name="legalValue7" />
+                <Parameter Type="System.String" Name="legalValue8" />
+            </Instance>
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is not one of the legal options: '{3}', '{4}', '{5}', '{6}', '{7}', '{8}', '{9}', '{10}', '{11}', '{12}', '{13}', '{14}', '{15}', '{16}', '{17}', '{18}', '{19}', '{20}', '{21}', '{22}', '{23}', '{24}', '{25}', '{26}', '{27}', or '{28}'.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+                <Parameter Type="System.String" Name="legalValue1" />
+                <Parameter Type="System.String" Name="legalValue2" />
+                <Parameter Type="System.String" Name="legalValue3" />
+                <Parameter Type="System.String" Name="legalValue4" />
+                <Parameter Type="System.String" Name="legalValue5" />
+                <Parameter Type="System.String" Name="legalValue6" />
+                <Parameter Type="System.String" Name="legalValue7" />
+                <Parameter Type="System.String" Name="legalValue8" />
+                <Parameter Type="System.String" Name="legalValue9" />
+                <Parameter Type="System.String" Name="legalValue10" />
+                <Parameter Type="System.String" Name="legalValue11" />
+                <Parameter Type="System.String" Name="legalValue12" />
+                <Parameter Type="System.String" Name="legalValue13" />
+                <Parameter Type="System.String" Name="legalValue14" />
+                <Parameter Type="System.String" Name="legalValue15" />
+                <Parameter Type="System.String" Name="legalValue16" />
+                <Parameter Type="System.String" Name="legalValue17" />
+                <Parameter Type="System.String" Name="legalValue18" />
+                <Parameter Type="System.String" Name="legalValue19" />
+                <Parameter Type="System.String" Name="legalValue20" />
+                <Parameter Type="System.String" Name="legalValue21" />
+                <Parameter Type="System.String" Name="legalValue22" />
+                <Parameter Type="System.String" Name="legalValue23" />
+                <Parameter Type="System.String" Name="legalValue24" />
+                <Parameter Type="System.String" Name="legalValue25" />
+                <Parameter Type="System.String" Name="legalValue26" />
+            </Instance>
+        </Message>
+        <Message Id="CustomActionMultipleSources" Number="22">
+            <Instance>
+                The {0}/@{1} attribute cannot coexist with a previously specified attribute on this element.  The {0} element may only have one of the following source attributes specified at a time: {2}, {3}, {4}, {5}, or {6}.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="attributeName1" />
+                <Parameter Type="System.String" Name="attributeName2" />
+                <Parameter Type="System.String" Name="attributeName3" />
+                <Parameter Type="System.String" Name="attributeName4" />
+                <Parameter Type="System.String" Name="attributeName5" />
+            </Instance>
+        </Message>
+        <Message Id="CustomActionMultipleTargets" Number="23">
+            <Instance>
+                The {0}/@{1} attribute cannot coexist with a previously specified attribute on this element.  The {0} element may only have one of the following target attributes specified at a time: {2}, {3}, {4}, {5}, {6}, {7}, or {8}.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="attributeName1" />
+                <Parameter Type="System.String" Name="attributeName2" />
+                <Parameter Type="System.String" Name="attributeName3" />
+                <Parameter Type="System.String" Name="attributeName4" />
+                <Parameter Type="System.String" Name="attributeName5" />
+                <Parameter Type="System.String" Name="attributeName6" />
+                <Parameter Type="System.String" Name="attributeName7" />
+            </Instance>
+        </Message>
+        <Message Id="CustomActionIllegalInnerText" Number="24">
+            <Instance>
+                The {0} element contains illegal inner text: '{1}'.  It may not contain inner text unless the {2} attribute is specified.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="innerText" />
+                <Parameter Type="System.String" Name="attributeName" />
+            </Instance>
+        </Message>
+        <Message Id="DirectoryRootWithoutName" Number="25">
+            <Instance>
+                The {0} element requires the {1} attribute because there is no parent {0} element.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalShortFilename" Number="26">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is not a valid 8.3-compliant name.  Legal names contain no more than 8 non-period characters followed by an optional period and extension of no more than 3 non-period characters.  Any character except for the follow may be used: \ ? | &gt; &lt; : / * " + , ; = [ ] (space).
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalLongFilename" Number="27">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is not a valid filename because it contains illegal characters. Legal filenames contain no more than 260 characters and must contain at least one non-period character. Any character except for the follow may be used: \ ? | &gt; &lt; : / * ".
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+            </Instance>
+            <Instance>
+                The {0}/@{1} attribute's value '{2}' contains a invalid filename '{3}'. Legal filenames contain no more than 260 characters and must contain at least one non-period character. Any character except for the follow may be used: \ ? | &gt; &lt; : / * ".
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+                <Parameter Type="System.String" Name="filename" />
+            </Instance>
+        </Message>
+        <Message Id="TableNameTooLong" Number="28">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is too long for a table name.  It cannot be more than than 31 characters long.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+            </Instance>
+        </Message>
+        <Message Id="FeatureConfigurableDirectoryNotUppercase" Number="29">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', contains lowercase characters.  Since this directory is user-configurable, it needs to be a public property.  This means the value must be completely uppercase.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+            </Instance>
+        </Message>
+        <Message Id="FeatureCannotFavorAndDisallowAdvertise" Number="30">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', cannot coexist with the {3} attribute's value of '{4}'.  These options would ask the installer to disallow the advertised state for this feature while at the same time favoring it.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+                <Parameter Type="System.String" Name="otherAttributeName" />
+                <Parameter Type="System.String" Name="otherValue" />
+            </Instance>
+        </Message>
+        <Message Id="FeatureCannotFollowParentAndFavorLocalOrSource" Number="31">
+            <Instance>
+                The {0}/@{1} attribute cannot be specified if the {2} attribute's value is '{3}'.  These options would ask the installer to force this feature to follow the parent installation state and simultaneously favor a particular installation state just for this feature.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="otherAttributeName" />
+                <Parameter Type="System.String" Name="otherValue" />
+            </Instance>
+        </Message>
+        <Message Id="MediaEmbeddedCabinetNameTooLong" Number="32">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is {3} characters long.  The name is too long for an embedded cabinet.  It cannot be more than than 62 characters long.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+                <Parameter Type="System.Int32" Name="length" />
+            </Instance>
+        </Message>
+        <Message Id="RegistrySubElementCannotBeRemoved" Number="33">
+            <Instance>
+                The {0}/{1} element cannot be specified if the {2} attribute's value is '{3}' or '{4}'.
+                <Parameter Type="System.String" Name="registryElementName" />
+                <Parameter Type="System.String" Name="registryValueElementName" />
+                <Parameter Type="System.String" Name="actionAttributeName" />
+                <Parameter Type="System.String" Name="removeValue" />
+                <Parameter Type="System.String" Name="removeKeyOnInstallValue" />
+            </Instance>
+        </Message>
+        <Message Id="RegistryMultipleValuesWithoutMultiString" Number="34">
+            <Instance>
+                The {0}/@{1} attribute and a {0}/{2} element cannot both be specified.  Only one may be specified if the {3} attribute's value is not 'multiString'.
+                <Parameter Type="System.String" Name="registryElementName" />
+                <Parameter Type="System.String" Name="valueAttributeName" />
+                <Parameter Type="System.String" Name="registryValueElementName" />
+                <Parameter Type="System.String" Name="typeAttributeName" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalAttributeWithOtherAttribute" Number="35">
+            <Instance>
+                The {0}/@{1} attribute cannot be specified when attribute {2} is present.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="otherAttributeName" />
+            </Instance>
+            <Instance>
+                The {0}/@{1} attribute cannot be specified when attribute {2} is present with value '{3}'.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="otherAttributeName" />
+                <Parameter Type="System.String" Name="otherAttributeValue" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalAttributeWithOtherAttributes" Number="36">
+            <Instance>
+                The {0}/@{1} attribute cannot be specified when attribute {2} or {3} is also present.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="otherAttributeName1" />
+                <Parameter Type="System.String" Name="otherAttributeName2" />
+            </Instance>
+            <Instance>
+                The {0}/@{1} attribute cannot be specified when attribute {2}, {3}, or {4} is also present.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="otherAttributeName1" />
+                <Parameter Type="System.String" Name="otherAttributeName2" />
+                <Parameter Type="System.String" Name="otherAttributeName3" />
+            </Instance>
+            <Instance>
+                The {0}/@{1} attribute cannot be specified when attribute {2}, {3}, {4}, or {5} is also present.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="otherAttributeName1" />
+                <Parameter Type="System.String" Name="otherAttributeName2" />
+                <Parameter Type="System.String" Name="otherAttributeName3" />
+                <Parameter Type="System.String" Name="otherAttributeName4" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalAttributeWithoutOtherAttributes" Number="37">
+            <Instance>
+                The {0}/@{1} attribute can only be specified with the following attribute {2} present.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="otherAttributeName" />
+            </Instance>
+            <Instance>
+                The {0}/@{1} attribute can only be specified with one of the following attributes: {2} or {3} present.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="otherAttributeName1" />
+                <Parameter Type="System.String" Name="otherAttributeName2" />
+            </Instance>
+            <Instance>
+                The {0}/@{1} attribute can only be specified with one of the following attributes: {2} or {3} present with value '{4}'.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="otherAttributeName1" />
+                <Parameter Type="System.String" Name="otherAttributeName2" />
+                <Parameter Type="System.String" Name="otherAttributeValue" />
+                <Parameter Type="System.Boolean" Name="uniquifier" />
+            </Instance>
+            <Instance>
+                The {0}/@{1} attribute can only be specified with one of the following attributes: {2}, {3}, or {4} present.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="otherAttributeName1" />
+                <Parameter Type="System.String" Name="otherAttributeName2" />
+                <Parameter Type="System.String" Name="otherAttributeName3" />
+            </Instance>
+            <Instance>
+                The {0}/@{1} attribute can only be specified with one of the following attributes: {2}, {3}, {4}, or {5} present.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="otherAttributeName1" />
+                <Parameter Type="System.String" Name="otherAttributeName2" />
+                <Parameter Type="System.String" Name="otherAttributeName3" />
+                <Parameter Type="System.String" Name="otherAttributeName4" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalAttributeValueWithoutOtherAttribute" Number="38">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', can only be specified with attribute {3} present with value '{4}'.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="attributeValue" />
+                <Parameter Type="System.String" Name="otherAttributeName" />
+                <Parameter Type="System.String" Name="otherAttributeValue" />
+            </Instance>
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', cannot be specified without attribute {3} present.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="attributeValue" />
+                <Parameter Type="System.String" Name="otherAttributeName" />
+            </Instance>
+        </Message>
+        <Message Id="IntegralValueSentinelCollision" Number="39">
+            <Instance>
+                The integer value {0} collides with a sentinel value in the compiler code.
+                <Parameter Type="System.Int32" Name="value" />
+            </Instance>
+            <Instance>
+                The long integral value {0} collides with a sentinel value in the compiler code.
+                <Parameter Type="System.Int64" Name="value" />
+            </Instance>
+        </Message>
+        <Message Id="ExampleGuid" Number="40">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is not a legal Guid value.  A Guid needs to be generated and put in place of '{2}' in the source file.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+            </Instance>
+        </Message>
+        <Message Id="TooManyChildren" Number="41">
+            <Instance>
+                The {0} element contains multiple {1} child elements.  There can only be one {1} child element per {0} element.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="childElementName" />
+            </Instance>
+        </Message>
+        <Message Id="ComponentMultipleKeyPaths" Number="42">
+            <Instance>
+                The {0} element has multiple key paths set.  The key path may only be set to '{2}' in extension elements that support it or one of the following locations: {0}/@{1}, {3}/@{1}, {4}/@{1}, or {5}/@{1}.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+                <Parameter Type="System.String" Name="fileElementName" />
+                <Parameter Type="System.String" Name="registryElementName" />
+                <Parameter Type="System.String" Name="odbcDataSourceElementName" />
+            </Instance>
+        </Message>
+        <Message Id="CabClosureFailed" Number="43" SourceLineNumbers="no">
+            <Instance>
+                Failed to close cab '{0}'.
+                <Parameter Type="System.String" Name="cabinet" />
+            </Instance>
+            <Instance>
+                Failed to close cab '{0}', error: {1}.
+                <Parameter Type="System.String" Name="cabinet" />
+                <Parameter Type="System.Int32" Name="error" />
+            </Instance>
+        </Message>
+        <Message Id="ExpectedAttributes" Number="44">
+            <Instance>
+                The {0} element's {1} or {2} attribute was not found; one of these is required.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName1" />
+                <Parameter Type="System.String" Name="attributeName2" />
+            </Instance>
+            <Instance>
+                The {0} element's {1}, {2}, or {3} attribute was not found; one of these is required.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName1" />
+                <Parameter Type="System.String" Name="attributeName2" />
+                <Parameter Type="System.String" Name="attributeName3" />
+            </Instance>
+            <Instance>
+                The {0} element's {1}, {2}, {3}, or {4} attribute was not found; one of these is required.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName1" />
+                <Parameter Type="System.String" Name="attributeName2" />
+                <Parameter Type="System.String" Name="attributeName3" />
+                <Parameter Type="System.String" Name="attributeName4" />
+            </Instance>
+            <Instance>
+                The {0} element's {1}, {2}, {3}, {4}, or {5} attribute was not found; one of these is required.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName1" />
+                <Parameter Type="System.String" Name="attributeName2" />
+                <Parameter Type="System.String" Name="attributeName3" />
+                <Parameter Type="System.String" Name="attributeName4" />
+                <Parameter Type="System.String" Name="attributeName5" />
+            </Instance>
+            <Instance>
+                The {0} element's {1}, {2}, {3}, {4}, {5}, or {6} attribute was not found; one of these is required.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName1" />
+                <Parameter Type="System.String" Name="attributeName2" />
+                <Parameter Type="System.String" Name="attributeName3" />
+                <Parameter Type="System.String" Name="attributeName4" />
+                <Parameter Type="System.String" Name="attributeName5" />
+                <Parameter Type="System.String" Name="attributeName6" />
+            </Instance>
+            <Instance>
+                The {0} element's {1}, {2}, {3}, {4}, {5}, {6}, or {7} attribute was not found; one of these is required.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName1" />
+                <Parameter Type="System.String" Name="attributeName2" />
+                <Parameter Type="System.String" Name="attributeName3" />
+                <Parameter Type="System.String" Name="attributeName4" />
+                <Parameter Type="System.String" Name="attributeName5" />
+                <Parameter Type="System.String" Name="attributeName6" />
+                <Parameter Type="System.String" Name="attributeName7" />
+            </Instance>
+        </Message>
+        <Message Id="ExpectedAttributesWithOtherAttribute" Number="45">
+            <Instance>
+                The {0} element's {1} or {2} attribute was not found; at least one of these attributes must be specified.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName1" />
+                <Parameter Type="System.String" Name="attributeName2" />
+            </Instance>
+            <Instance>
+                The {0} element's {1} or {2} attribute was not found; one of these is required when attribute {3} is present.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName1" />
+                <Parameter Type="System.String" Name="attributeName2" />
+                <Parameter Type="System.String" Name="otherAttributeName" />
+            </Instance>
+            <Instance>
+                The {0} element's {1} or {2} attribute was not found; one of these is required when attribute {3} has a value of '{4}'.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName1" />
+                <Parameter Type="System.String" Name="attributeName2" />
+                <Parameter Type="System.String" Name="otherAttributeName" />
+                <Parameter Type="System.String" Name="otherAttributeValue" />
+            </Instance>
+        </Message>
+        <Message Id="ExpectedAttributesWithoutOtherAttribute" Number="46">
+            <Instance>
+                The {0} element's {1} or {2} attribute was not found; one of these is required without attribute {3} present.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName1" />
+                <Parameter Type="System.String" Name="attributeName2" />
+                <Parameter Type="System.String" Name="otherAttributeName" />
+            </Instance>
+        </Message>
+        <Message Id="MissingTypeLibFile" Number="47">
+            <Instance>
+                The {0} element is non-advertised and therefore requires a parent {1} element.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="fileElementName" />
+            </Instance>
+        </Message>
+        <Message Id="InvalidDocumentElement" Number="48">
+            <Instance>
+                The document element name '{0}' is invalid.  A WiX {1} file must use '{2}' as the document element name.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="fileType" />
+                <Parameter Type="System.String" Name="expectedElementName" />
+            </Instance>
+        </Message>
+        <Message Id="ExpectedAttributeInElementOrParent" Number="49">
+            <Instance>
+                The {0}/@{1} attribute was not found or empty; it is required, or it can be specified in the parent {2} element.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="parentElementName" />
+            </Instance>
+            <Instance>
+                The {0}/@{1} attribute was not found or empty; it is required, or it can be specified in the parent {2}/@{3} attribute.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="parentElementName" />
+                <Parameter Type="System.String" Name="parentAttributeName" />
+            </Instance>
+        </Message>
+        <Message Id="UnauthorizedAccess" Number="50" SourceLineNumbers="no">
+            <Instance>
+                Access to the path '{0}' is denied.
+                <Parameter Type="System.String" Name="filePath" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalModuleExclusionLanguageAttributes" Number="51">
+            <Instance>Cannot set both ExcludeLanguage and ExcludeExceptLanguage attributes on a ModuleExclusion element.</Instance>
+        </Message>
+        <Message Id="NoFirstControlSpecified" Number="52">
+            <Instance>
+                The '{0}' dialog element does not have a valid tabbable control. You must either have a tabbable control that is not marked TabSkip='yes', or you must mark a control TabSkip='no'. If you have a page with no tabbable controls (a progress page, for example), you might want to set the first Text control to be TabSkip='no'.
+                <Parameter Type="System.String" Name="dialogName" />
+            </Instance>
+        </Message>
+        <Message Id="NoDataForColumn" Number="53">
+            <Instance>
+                There is no data for column '{0}' in a contained row of custom table '{1}'.  A non-null value must be supplied for this column.
+                <Parameter Type="System.String" Name="columnName" />
+                <Parameter Type="System.String" Name="tableName" />
+            </Instance>
+        </Message>
+        <Message Id="ValueAndMaskMustBeSameLength" Number="54">
+            <Instance>
+                The FileTypeMask/@Value and FileTypeMask/@Mask attributes must be the same length.
+            </Instance>
+        </Message>
+        <Message Id="TooManySearchElements" Number="55">
+            <Instance>
+                Only one search element can appear under a '{0}' element.
+                <Parameter Type="System.String" Name="elementName" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalAttributeExceptOnElement" Number="56">
+            <Instance>
+                The {1} attribute can only be specified on the {2} element.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="expectedElementName" />
+            </Instance>
+        </Message>
+        <Message Id="SearchElementRequired" Number="57">
+            <Instance>
+                A '{0}' element must have a search element as a child.
+                <Parameter Type="System.String" Name="elementName" />
+            </Instance>
+        </Message>
+        <Message Id="MultipleIdentifiersFound" Number="58">
+            <Instance>
+                Under a '{0}' element, multiple identifiers were found: '{1}' and '{2}'.  All search elements under this element must have the same id.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="identifier" />
+                <Parameter Type="System.String" Name="mismatchIdentifier" />
+            </Instance>
+        </Message>
+        <Message Id="AdvertiseStateMustMatch" Number="59">
+            <Instance>
+                The advertise state of this element: '{0}', does not match the advertise state set on the parent element: '{1}'.
+                <Parameter Type="System.String" Name="advertiseState" />
+                <Parameter Type="System.String" Name="parentAdvertiseState" />
+            </Instance>
+        </Message>
+        <Message Id="DuplicateContextValue" Number="60">
+            <Instance>
+                The context value '{0}' was duplicated. Context values must be distinct.
+                <Parameter Type="System.String" Name="contextValue" />
+            </Instance>
+        </Message>
+        <Message Id="RelativePathForRegistryElement" Number="61">
+            <Instance>
+                Cannot convert RelativePath into Registry elements.
+            </Instance>
+        </Message>
+        <Message Id="IllegalAttributeWhenNested" Number="62">
+            <Instance>
+                The {0}/@{1} attribute cannot be specified when the {0} element is nested underneath a {2} element. If this {0} is a member of a ComponentGroup where ComponentGroup/@{1} is set, then the {0}/@{1} attribute should be removed.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="parentElement" />
+            </Instance>
+        </Message>
+        <Message Id="ExpectedElement" Number="63">
+            <Instance>
+                A {0} element must have at least one child element of type {1}.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="childName" />
+            </Instance>
+            <Instance>
+                A {0} element must have at least one child element of type {1} or {2}.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="childName1" />
+                <Parameter Type="System.String" Name="childName2" />
+            </Instance>
+            <Instance>
+                A {0} element must have at least one child element of type {1}, {2}, or {3}.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="childName1" />
+                <Parameter Type="System.String" Name="childName2" />
+                <Parameter Type="System.String" Name="childName3" />
+            </Instance>
+            <Instance>
+                A {0} element must have at least one child element of type {1}, {2}, {3}, or {4}.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="childName1" />
+                <Parameter Type="System.String" Name="childName2" />
+                <Parameter Type="System.String" Name="childName3" />
+                <Parameter Type="System.String" Name="childName4" />
+            </Instance>
+        </Message>
+        <Message Id="RegistryRootInvalid" Number="64">
+            <Instance>
+                Registry/@Root attribute is invalid on a nested Registry element.  Either remove the Root attribute or move the Registry element so it is not nested under another Registry element.
+            </Instance>
+        </Message>
+        <Message Id="IllegalYesNoDefaultValue" Number="65">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is not a legal yes/no/default value.  The only legal values are 'default', 'no' or 'yes'.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalAttributeInMergeModule" Number="66">
+            <Instance>
+                The {0}/@{1} attribute cannot be specified in a merge module.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+            </Instance>
+        </Message>
+        <Message Id="GenericReadNotAllowed" Number="67">
+            <Instance>Permission elements cannot have GenericRead as the only permission specified. Include at least one other permission.</Instance>
+        </Message>
+        <Message Id="IllegalAttributeWithInnerText" Number="68">
+            <Instance>
+                The {0}/@{1} attribute cannot be specified when the element has body text as well. Specify either the attribute or the body, but not both.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+            </Instance>
+        </Message>
+        <Message Id="SearchElementRequiredWithAttribute" Number="69">
+            <Instance>
+                A {0} element must have a search element as a child when the {0}/@{1} attribute has the value '{2}'.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="attributeValue" />
+            </Instance>
+        </Message>
+        <Message Id="CannotAuthorSpecialProperties" Number="70">
+            <Instance>
+                The {0} property was specified. Special MSI properties cannot be authored.  Use the attributes on the Property element instead.
+                <Parameter Type="System.String" Name="propertyName" />
+            </Instance>
+        </Message>
+        <Message Id="NeedSequenceBeforeOrAfter" Number="72">
+            <Instance>
+                A {0} element must have a Before attribute, After attribute, or a Sequence attribute.
+                <Parameter Type="System.String" Name="elementName" />
+            </Instance>
+        </Message>
+        <Message Id="ValueNotSupported" Number="73">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}, is not supported by the Windows Installer.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="attributeValue" />
+            </Instance>
+        </Message>
+        <Message Id="TabbableControlNotAllowedInBillboard" Number="74">
+            <Instance>
+                A {0} element was specified with Type='{1}' and TabSkip='no'. Tabbable controls are not allowed in Billboards.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="controlType" />
+            </Instance>
+        </Message>
+        <Message Id="CheckBoxValueOnlyValidWithCheckBox" Number="75">
+            <Instance>
+                A {0} element was specified with Type='{1}' and a CheckBoxValue. Check box values can only be specified with Type='CheckBox'.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="controlType" />
+            </Instance>
+        </Message>
+        <Message Id="CabFileDoesNotExist" Number="76" SourceLineNumbers="no">
+            <Instance>
+                Attempted to extract cab '{0}' from merge module '{1}' to directory '{2}'. The cab file was not found. This usually means that you have a merge module without a cabinet inside it.
+                <Parameter Type="System.String" Name="cabName" />
+                <Parameter Type="System.String" Name="mergeModulePath" />
+                <Parameter Type="System.String" Name="directoryName" />
+            </Instance>
+        </Message>
+        <Message Id="RadioButtonTypeInconsistent" Number="77">
+            <Instance>All RadioButton elements in a RadioButtonGroup must be consistent with their use of the Bitmap, Icon, and Text attributes. Ensure all of the RadioButton elements in this group have the same attribute specified.</Instance>
+        </Message>
+        <Message Id="RadioButtonBitmapAndIconDisallowed" Number="78">
+            <Instance>RadioButtonGroup elements that contain RadioButton elements with Bitmap or Icon attributes set to "yes" can only be specified under a Control element.  Move your RadioButtonGroup element as a child of the appropriate Control element.</Instance>
+        </Message>
+        <Message Id="IllegalSuppressWarningId" Number="79" SourceLineNumbers="no">
+            <Instance>
+                Illegal value '{0}' for the -sw&lt;N&gt; command line option. Specify a particular warning number, like '-sw6' to suppress the warning with ID 6, or '-sw' alone to suppress all warnings.
+                <Parameter Type="System.String" Name="suppressedId" />
+            </Instance>
+        </Message>
+        <Message Id="PreprocessorIllegalForeachVariable" Number="80">
+            <Instance>
+                The variable named '{0}' is not allowed in a foreach expression.
+                <Parameter Type="System.String" Name="variableName" />
+            </Instance>
+        </Message>
+        <Message Id="PreprocessorMissingParameterPrefix" Number="81">
+            <Instance>
+                Could not find the prefix in parameter name: '{0}'.
+                <Parameter Type="System.String" Name="parameterName" />
+            </Instance>
+        </Message>
+        <Message Id="PreprocessorExtensionForParameterMissing" Number="82">
+            <Instance>
+                Could not find the preprocessor extension for parameter '{0}'.  A preprocessor extension is expected because the parameter prefix, '{1}', is not one of the standard types: 'env', 'res', 'sys', or 'var'.
+                <Parameter Type="System.String" Name="parameterName" />
+                <Parameter Type="System.String" Name="parameterPrefix" />
+            </Instance>
+        </Message>
+        <Message Id="CannotFindFile" Number="83">
+            <Instance>
+                The file with id '{0}' and name '{1}' could not be found with source path: '{2}'.
+                <Parameter Type="System.String" Name="fileId" />
+                <Parameter Type="System.String" Name="fileName" />
+                <Parameter Type="System.String" Name="filePath" />
+            </Instance>
+        </Message>
+        <Message Id="BinderFileManagerMissingFile" Number="84">
+            <Instance>
+                {0}
+                <Parameter Type="System.String" Name="exceptionMessage" />
+            </Instance>
+        </Message>
+        <Message Id="InvalidFileName" Number="85">
+            <Instance>
+                Invalid file name '{0}'.
+                <Parameter Type="System.String" Name="fileName" />
+            </Instance>
+        </Message>
+        <Message Id="ReferenceLoopDetected" Number="86">
+            <Instance>
+                A circular reference of groups was detected. The infinite loop includes: {0}. Group references must form a directed acyclic graph.
+                <Parameter Type="System.String" Name="loopList" />
+            </Instance>
+        </Message>
+        <Message Id="GuidContainsLowercaseLetters" Number="87">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is a mixed-case guid.  All letters in a guid value should be uppercase.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+            </Instance>
+        </Message>
+        <Message Id="InvalidDateTimeFormat" Number="88">
+            <Instance>
+                The {0}/@{1} attribute's value '{2}' is not a valid date/time value. A date/time value should follow the format YYYY-MM-DDTHH:mm:ss.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+            </Instance>
+        </Message>
+        <Message Id="MultipleEntrySections" Number="89">
+            <Instance>
+                Multiple entry sections '{0}' and '{1}' found.  Only one entry section may be present in a single target.
+                <Parameter Type="System.String" Name="sectionName1" />
+                <Parameter Type="System.String" Name="sectionName2" />
+            </Instance>
+        </Message>
+        <Message Id="MultipleEntrySections2" Number="90">
+            <Instance>Location of entry section related to previous error.</Instance>
+        </Message>
+        <Message Id="DuplicateSymbol" Number="91">
+            <Instance>
+                Duplicate symbol '{0}' found. This typically means that an Id is duplicated. Access modifiers (internal, protected, private) cannot prevent these conflicts. Ensure all your identifiers of a given type (File, Component, Feature) are unique.
+                <Parameter Type="System.String" Name="symbolName" />
+            </Instance>
+            <Instance>
+                Duplicate symbol '{0}' referenced by {1}. This typically means that an Id is duplicated. Ensure all your identifiers of a given type (File, Component, Feature) are unique or use an access modifier to scope the identfier.
+                <Parameter Type="System.String" Name="symbolName" />
+                <Parameter Type="System.String" Name="referencingSourceLineNumber" />
+            </Instance>
+        </Message>
+        <Message Id="DuplicateSymbol2" Number="92">
+            <Instance>Location of symbol related to previous error.</Instance>
+        </Message>
+        <Message Id="MissingEntrySection" Number="93" SourceLineNumbers="no">
+            <Instance>
+                Could not find entry section in provided list of intermediates. Expected section of type '{0}'.
+                <Parameter Type="System.String" Name="sectionType" />
+            </Instance>
+        </Message>
+        <Message Id="UnresolvedReference" Number="94">
+            <Instance>
+                The identifier '{0}' could not be found. Ensure you have typed the reference correctly and that all the necessary inputs are provided to the linker.
+                <Parameter Type="System.String" Name="symbolName" />
+            </Instance>
+            <Instance>
+                The identifier '{0}' is inaccessible due to its protection level.
+                <Parameter Type="System.String" Name="symbolName" />
+                <Parameter Type="WixToolset.Data.AccessModifier" Name="accessModifier" />
+            </Instance>
+        </Message>
+        <Message Id="MultiplePrimaryReferences" Number="95">
+            <Instance>
+                Multiple primary references were found for {0} '{1}' in {2} '{3}' and {4} '{5}'.
+                <Parameter Type="System.String" Name="crefChildType" />
+                <Parameter Type="System.String" Name="crefChildId" />
+                <Parameter Type="System.String" Name="crefParentType" />
+                <Parameter Type="System.String" Name="crefParentId" />
+                <Parameter Type="System.String" Name="conflictParentType" />
+                <Parameter Type="System.String" Name="conflictParentId" />
+            </Instance>
+        </Message>
+        <Message Id="ComponentReferencedTwice" Number="96">
+            <Instance>
+                Component {0} cannot be contained in a Module twice.
+                <Parameter Type="System.String" Name="crefChildId" />
+            </Instance>
+        </Message>
+        <Message Id="DuplicateModuleFileIdentifier" Number="97">
+            <Instance>
+                The merge module '{0}' contains a file identifier, '{1}', that is duplicated either in another merge module or in a File/@Id attribute.  File identifiers must be unique.  Please change one of the file identifiers to a different value.
+                <Parameter Type="System.String" Name="moduleId" />
+                <Parameter Type="System.String" Name="fileId" />
+            </Instance>
+        </Message>
+        <Message Id="DuplicateModuleCaseInsensitiveFileIdentifier" Number="98">
+            <Instance>
+                The merge module '{0}' contains 2 or more file identifiers that only differ by case: '{1}' and '{2}'.  The WiX toolset extracts merge module files to the file system using these identifiers.  Since most file systems are not case-sensitive a collision is likely.  Please contact the owner of the merge module for a fix.
+                <Parameter Type="System.String" Name="moduleId" />
+                <Parameter Type="System.String" Name="fileId1" />
+                <Parameter Type="System.String" Name="fileId2" />
+            </Instance>
+        </Message>
+        <Message Id="ImplicitComponentKeyPath" Number="99">
+            <Instance>
+                The component '{0}' does not have an explicit key path specified.  If the ordering of the elements under the Component element changes, the key path will also change.  To prevent accidental changes, the key path should be set to 'yes' in one of the following locations: Component/@KeyPath, File/@KeyPath, ODBCDataSource/@KeyPath, or Registry/@KeyPath.
+                <Parameter Type="System.String" Name="componentId" />
+            </Instance>
+        </Message>
+        <Message Id="DuplicateLocalizationIdentifier" Number="100">
+            <Instance>
+                The localization identifier '{0}' has been duplicated in multiple locations.  Please resolve the conflict.
+                <Parameter Type="System.String" Name="localizationId" />
+            </Instance>
+        </Message>
+        <Message Id="LocalizationVariableUnknown" Number="102">
+            <Instance>
+                The localization variable !(loc.{0}) is unknown.  Please ensure the variable is defined.
+                <Parameter Type="System.String" Name="variableId" />
+            </Instance>
+        </Message>
+        <Message Id="FileNotFound" Number="103">
+            <Instance>
+                The system cannot find the file '{0}'.
+                <Parameter Type="System.String" Name="file" />
+            </Instance>
+            <Instance>
+                The system cannot find the file '{0}' with type '{1}'.
+                <Parameter Type="System.String" Name="file" />
+                <Parameter Type="System.String" Name="fileType" />
+            </Instance>
+        </Message>
+        <Message Id="InvalidXml" Number="104">
+            <Instance>
+                Not a valid {0} file; detail: {1}
+                <Parameter Type="System.String" Name="fileType" />
+                <Parameter Type="System.String" Name="detail" />
+            </Instance>
+        </Message>
+        <Message Id="ProgIdNestedTooDeep" Number="105">
+            <Instance>ProgId elements may not be nested more than 1 level deep.</Instance>
+        </Message>
+        <Message Id="CanNotHaveTwoParents" Number="106">
+            <Instance>
+                The DirectorySearchRef {0} can not have a Parent attribute {1} and also be nested under parent element {2}
+                <Parameter Type="System.String" Name="directorySearch" />
+                <Parameter Type="System.String" Name="parentAttribute" />
+                <Parameter Type="System.String" Name="parentElement" />
+            </Instance>
+        </Message>
+        <Message Id="SchemaValidationFailed" Number="107">
+            <Instance>
+                Schema validation failed with the following error at line {1}, column {2}: {0}
+                <Parameter Type="System.String" Name="validationError" />
+                <Parameter Type="System.Int32" Name="lineNumber" />
+                <Parameter Type="System.Int32" Name="linePosition" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalVersionValue" Number="108">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is not a valid version.  Legal version values should look like 'x.x.x.x' where x is an integer from 0 to 65534.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+            </Instance>
+        </Message>
+        <Message Id="CustomTableNameTooLong" Number="109">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is too long for a table name.  It cannot be more than than 31 characters long.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+            </Instance>
+        </Message>
+        <Message Id="CustomTableIllegalColumnWidth" Number="110">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is not a valid column width.  Valid column widths are 2 or 4.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.Int32" Name="value" />
+            </Instance>
+        </Message>
+        <Message Id="CustomTableMissingPrimaryKey" Number="111">
+            <Instance>The CustomTable is missing a Column element with the PrimaryKey attribute set to 'yes'.  At least one column must be marked as the primary key.</Instance>
+        </Message>
+        <Message Id="TypeSpecificationForExtensionRequired" Number="113" SourceLineNumbers="no">
+            <Instance>
+                The parameter '{0}' must be followed by the extension's type specification.  The type specification should be a fully qualified class and assembly identity, for example: "MyNamespace.MyClass,myextension.dll".
+                <Parameter Type="System.String" Name="parameter" />
+            </Instance>
+        </Message>
+        <Message Id="FilePathRequired" SourceLineNumbers="no" Number="114">
+            <Instance>
+                The parameter '{0}' must be followed by a file path.
+                <Parameter Type="System.String" Name="parameter" />
+            </Instance>
+        </Message>
+        <Message Id="DirectoryPathRequired" Number="115" SourceLineNumbers="no">
+            <Instance>
+                The parameter '{0}' must be followed by a directory path.
+                <Parameter Type="System.String" Name="parameter" />
+            </Instance>
+        </Message>
+        <Message Id="FileOrDirectoryPathRequired" Number="116" SourceLineNumbers="no">
+            <Instance>
+                The parameter '{0}' must be followed by a file or directory path.  To specify a directory path the string must end with a backslash, for example: "C:\Path\".
+                <Parameter Type="System.String" Name="parameter" />
+            </Instance>
+        </Message>
+        <Message Id="PathCannotContainQuote" Number="117" SourceLineNumbers="no">
+            <Instance>
+                Path '{0}' contains a literal quote character. Quotes are often accidentally introduced when trying to refer to a directory path with spaces in it, such as "C:\Out Directory\" -- the backslash before the quote acts an escape character. The correct representation for that path is: "C:\Out Directory\\".
+                <Parameter Type="System.String" Name="fileName" />
+            </Instance>
+        </Message>
+        <Message Id="AdditionalArgumentUnexpected" Number="118" SourceLineNumbers="no">
+            <Instance>
+                Additional argument '{0}' was unexpected.  Remove the argument and add the '-?' switch for more information.
+                <Parameter Type="System.String" Name="argument" />
+            </Instance>
+        </Message>
+        <Message Id="RegistryNameValueIncorrect" Number="119">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is incorrect.  It should not contain values of '+', '-', or '*' when the {0}/@Value attribute is empty.  Instead, use the proper element and attributes: for Name='+' use RegistryKey/@Action='createKey', for Name='-' use RemoveRegistryKey/@Action='removeOnUninstall', for Name='*' use RegistryKey/@Action='createAndRemoveOnUninstall'.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+            </Instance>
+        </Message>
+        <Message Id="FamilyNameTooLong" Number="120">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is {3} characters long.  This is too long for a family name because the maximum allowed length is 8 characters long.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+                <Parameter Type="System.Int32" Name="length" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalFamilyName" Number="121">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', contains illegal characters for a family name.  Legal values include letters, numbers, and underscores.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalLongValue" Number="122">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is not a legal long value.  Legal long values are from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+            </Instance>
+        </Message>
+        <Message Id="IntegralValueOutOfRange" Number="123">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is not in the range of legal values.  Legal values for this attribute are from {3} to {4}.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.Int32" Name="value" />
+                <Parameter Type="System.Int32" Name="minimum" />
+                <Parameter Type="System.Int32" Name="maximum" />
+            </Instance>
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is not in the range of legal values.  Legal values for this attribute are from {3} to {4}.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.Int64" Name="value" />
+                <Parameter Type="System.Int64" Name="minimum" />
+                <Parameter Type="System.Int64" Name="maximum" />
+            </Instance>
+        </Message>
+        <Message Id="DuplicateExtensionXmlSchemaNamespace" Number="125" SourceLineNumbers="no">
+            <Instance>
+                The extension '{0}' uses the same xml schema namespace, '{1}', as previously loaded extension '{2}'.  Please either remove one of the extensions or rename the xml schema namespace to avoid the collision.
+                <Parameter Type="System.String" Name="extension" />
+                <Parameter Type="System.String" Name="extensionXmlSchemaNamespace" />
+                <Parameter Type="System.String" Name="collidingExtension" />
+            </Instance>
+        </Message>
+        <Message Id="DuplicateExtensionTable" Number="126" SourceLineNumbers="no">
+            <Instance>
+                The extension '{0}' contains a definition for table '{1}' that collides with a previously loaded table definition.  Please remove one of the conflicting extensions or rename one of the tables to avoid the collision.
+                <Parameter Type="System.String" Name="extension" />
+                <Parameter Type="System.String" Name="tableName" />
+            </Instance>
+        </Message>
+        <Message Id="DuplicateExtensionPreprocessorType" Number="127" SourceLineNumbers="no">
+            <Instance>
+                The extension '{0}' uses the same preprocessor variable prefix, '{1}', as previously loaded extension '{2}'.  Please remove one of the extensions or rename the prefix to avoid the collision.
+                <Parameter Type="System.String" Name="extension" />
+                <Parameter Type="System.String" Name="variablePrefix" />
+                <Parameter Type="System.String" Name="collidingExtension" />
+            </Instance>
+        </Message>
+        <Message Id="FileInUse" Number="128">
+            <Instance>
+                The process can not access the file '{0}' because it is being used by another process.
+                <Parameter Type="System.String" Name="file" />
+            </Instance>
+        </Message>
+        <Message Id="CannotOpenMergeModule" Number="129">
+            <Instance>
+                Cannot open the merge module '{0}' from file '{1}'.
+                <Parameter Type="System.String" Name="mergeModuleIdentifier" />
+                <Parameter Type="System.String" Name="mergeModuleFile" />
+            </Instance>
+        </Message>
+        <Message Id="DuplicatePrimaryKey" Number="130">
+            <Instance>
+                The primary key '{0}' is duplicated in table '{1}'.  Please remove one of the entries or rename a part of the primary key to avoid the collision.
+                <Parameter Type="System.String" Name="primaryKey" />
+                <Parameter Type="System.String" Name="tableName" />
+            </Instance>
+        </Message>
+        <Message Id="FileIdentifierNotFound" Number="131">
+            <Instance>
+                The file row with identifier '{0}' could not be found.
+                <Parameter Type="System.String" Name="fileIdentifier" />
+            </Instance>
+        </Message>
+        <Message Id="InvalidAssemblyFile" Number="132">
+            <Instance>
+                The assembly file '{0}' appears to be invalid.  Please ensure this is a valid assembly file and that the user has the appropriate access rights to this file.  More information: {1}
+                <Parameter Type="System.String" Name="assemblyFile" />
+                <Parameter Type="System.String" Name="moreInformation" />
+            </Instance>
+        </Message>
+        <Message Id="ExpectedEndElement" Number="133">
+            <Instance>
+                The end element matching the '{0}' start element was not found.
+                <Parameter Type="System.String" Name="elementName" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalCodepage" Number="134" SourceLineNumbers="no">
+            <Instance>
+                The code page '{0}' is not a valid Windows code page. Update the database's code page by modifying one of the following attributes: Product/@Codepage, Module/@Codepage, Patch/@Codepage, PatchCreation/@Codepage, or WixLocalization/@Codepage.
+                <Parameter Type="System.Int32" Name="codepage" />
+            </Instance>
+        </Message>
+        <Message Id="ExpectedMediaCabinet" Number="135">
+            <Instance>
+                The file '{0}' should be compressed but is not part of a compressed media. Files will be compressed if either the File/@Compressed or Package/@Compressed attributes are set to 'yes'.  This can be fixed by setting the Media/@Cabinet attribute for media '{1}'.
+                <Parameter Type="System.String" Name="fileId" />
+                <Parameter Type="System.Int32" Name="diskId" />
+            </Instance>
+        </Message>
+        <Message Id="InvalidIdt" Number="136">
+            <Instance>
+                There was an error importing the file '{0}'.
+                <Parameter Type="System.String" Name="idtFile" />
+            </Instance>
+            <Instance>
+                There was an error importing table '{1}' from file '{0}'.
+                <Parameter Type="System.String" Name="idtFile" />
+                <Parameter Type="System.String" Name="tableName" />
+            </Instance>
+        </Message>
+        <Message Id="InvalidSequenceTable" Number="137" SourceLineNumbers="no">
+            <Instance>
+                Found an invalid sequence table '{0}'.
+                <Parameter Type="System.String" Name="sequenceTableName" />
+            </Instance>
+        </Message>
+        <Message Id="ExpectedDirectory" Number="138" SourceLineNumbers="no">
+            <Instance>
+                The directory '{0}' could not be found.
+                <Parameter Type="System.String" Name="directory" />
+            </Instance>
+        </Message>
+        <Message Id="ComponentExpectedFeature" Number="139">
+            <Instance>
+                The component '{0}' is not assigned to a feature.  The component's {1} '{2}' requires it to be assigned to at least one feature.
+                <Parameter Type="System.String" Name="component" />
+                <Parameter Type="System.String" Name="type" />
+                <Parameter Type="System.String" Name="target" />
+            </Instance>
+        </Message>
+        <Message Id="RecursiveAction" Number="140" SourceLineNumbers="no">
+            <Instance>
+                The action '{0}' is recursively placed in the '{1}' table.
+                <Parameter Type="System.String" Name="action" />
+                <Parameter Type="System.String" Name="tableName" />
+            </Instance>
+        </Message>
+        <Message Id="VersionMismatch" Number="141">
+            <Instance>
+                The {0} file format version {1} is not compatible with the expected {0} file format version {2}.
+                <Parameter Type="System.String" Name="fileType" />
+                <Parameter Type="System.String" Name="version" />
+                <Parameter Type="System.String" Name="expectedVersion" />
+            </Instance>
+        </Message>
+        <Message Id="UnexpectedContentNode" Number="142">
+            <Instance>
+                The {0} element contains an unexpected xml node of type {1}.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="unexpectedNodeType" />
+            </Instance>
+        </Message>
+        <Message Id="UnexpectedColumnCount" Number="143">
+            <Instance>
+                A parsed row has more fields that contain data for table '{0}' than are defined. This is potentially because a standard table is being redefined as a custom table or is based on an older table schema.
+                <Parameter Type="System.String" Name="tableName" />
+            </Instance>
+        </Message>
+        <Message Id="InvalidExtension" Number="144" SourceLineNumbers="no">
+            <Instance>
+                The extension '{0}' could not be loaded.
+                <Parameter Type="System.String" Name="extension" />
+            </Instance>
+            <Instance>
+                The extension '{0}' could not be loaded because of the following reason: {1}
+                <Parameter Type="System.String" Name="extension" />
+                <Parameter Type="System.String" Name="invalidReason" />
+            </Instance>
+            <Instance>
+                The extension '{0}' is the wrong type: '{1}'.  The expected type was '{2}'.
+                <Parameter Type="System.String" Name="extension" />
+                <Parameter Type="System.String" Name="extensionType" />
+                <Parameter Type="System.String" Name="expectedType" />
+            </Instance>
+            <Instance>
+                The extension '{0}' is the wrong type: '{1}'.  The expected type was '{2}' or '{3}'.
+                <Parameter Type="System.String" Name="extension" />
+                <Parameter Type="System.String" Name="extensionType" />
+                <Parameter Type="System.String" Name="expectedType1" />
+                <Parameter Type="System.String" Name="expectedType2" />
+            </Instance>
+        </Message>
+        <Message Id="InvalidSubExpression" Number="145">
+            <Instance>
+                Found invalid subexpression '{0}' in expression '{1}'.
+                <Parameter Type="System.String" Name="subExpression" />
+                <Parameter Type="System.String" Name="expression" />
+            </Instance>
+        </Message>
+        <Message Id="UnmatchedPreprocessorInstruction" Number="146">
+            <Instance>
+                Found a &lt;?{1}?&gt; processing instruction without a matching &lt;?{0}?&gt; before it.
+                <Parameter Type="System.String" Name="beginInstruction" />
+                <Parameter Type="System.String" Name="endInstruction" />
+            </Instance>
+        </Message>
+        <Message Id="NonterminatedPreprocessorInstruction" Number="147">
+            <Instance>
+                Found a &lt;?{0}?&gt; processing instruction without a matching &lt;?{1}?&gt; after it.
+                <Parameter Type="System.String" Name="beginInstruction" />
+                <Parameter Type="System.String" Name="endInstruction" />
+            </Instance>
+        </Message>
+        <Message Id="ExpectedExpressionAfterNot" Number="148">
+            <Instance>
+                Expecting an argument for 'NOT' in expression '{0}'.
+                <Parameter Type="System.String" Name="expression" />
+            </Instance>
+        </Message>
+        <Message Id="InvalidPreprocessorVariable" Number="149">
+            <Instance>
+                Ill-formed preprocessor variable '$({0})'.  Variables must have a prefix (like 'var.', 'env.', or 'sys.') and a name at least 1 character long. If the literal string '$({0})' is desired, use '$$({0})'.
+                <Parameter Type="System.String" Name="variable" />
+            </Instance>
+        </Message>
+        <Message Id="UndefinedPreprocessorVariable" Number="150">
+            <Instance>
+                Undefined preprocessor variable '$({0})'.
+                <Parameter Type="System.String" Name="variableName" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalDefineStatement" Number="151">
+            <Instance>
+                The define statement '&lt;?define {0}?&gt;' is not well-formed.  Define statements should be in the form &lt;?define variableName = "variable value"?&gt;.
+                <Parameter Type="System.String" Name="defineStatement" />
+            </Instance>
+        </Message>
+        <Message Id="VariableDeclarationCollision" Number="152">
+            <Instance>
+                The variable '{0}' with value '{1}' was previously declared with value '{2}'.
+                <Parameter Type="System.String" Name="variableName" />
+                <Parameter Type="System.String" Name="variableValue" />
+                <Parameter Type="System.String" Name="variableCollidingValue" />
+            </Instance>
+        </Message>
+        <Message Id="CannotReundefineVariable" Number="153">
+            <Instance>
+                The variable '{0}' cannot be undefined because its already undefined.
+                <Parameter Type="System.String" Name="variableName" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalForeach" Number="154">
+            <Instance>
+                The foreach statement '{0}' is illegal.  The proper format for foreach is &lt;?foreach varName in valueList?&gt;.
+                <Parameter Type="System.String" Name="foreachStatement" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalParentAttributeWhenNested" Number="155">
+            <Instance>
+                The {0}/@{1} attribute cannot be specified when a {2} element is nested underneath the {0} element.
+                <Parameter Type="System.String" Name="parentElementName" />
+                <Parameter Type="System.String" Name="parentAttributeName" />
+                <Parameter Type="System.String" Name="childElement" />
+            </Instance>
+        </Message>
+        <Message Id="ExpectedEndforeach" Number="156">
+            <Instance>A &lt;?foreach?&gt; statement was found that had no matching &lt;?endforeach?&gt;.</Instance>
+        </Message>
+        <Message Id="UnmatchedQuotesInExpression" Number="158">
+            <Instance>
+                The quotes don't match in the expression '{0}'.
+                <Parameter Type="System.String" Name="expression" />
+            </Instance>
+        </Message>
+        <Message Id="UnmatchedParenthesisInExpression" Number="159">
+            <Instance>
+                The parenthesis don't match in the expression '{0}'.
+                <Parameter Type="System.String" Name="expression" />
+            </Instance>
+        </Message>
+        <Message Id="ExpectedVariable" Number="160">
+            <Instance>
+                A required variable was missing in the expression '{0}'.
+                <Parameter Type="System.String" Name="expression" />
+            </Instance>
+        </Message>
+        <Message Id="UnexpectedLiteral" Number="161">
+            <Instance>
+                An unexpected literal was found in the expression '{0}'.
+                <Parameter Type="System.String" Name="expression" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalIntegerInExpression" Number="162">
+            <Instance>
+                An illegal number was found in the expression '{0}'.
+                <Parameter Type="System.String" Name="expression" />
+            </Instance>
+        </Message>
+        <Message Id="UnexpectedPreprocessorOperator" Number="163">
+            <Instance>
+                The operator '{0}' is unexpected.
+                <Parameter Type="System.String" Name="operator" />
+            </Instance>
+        </Message>
+        <Message Id="UnexpectedEmptySubexpression" Number="164">
+            <Instance>
+                The empty subexpression is unexpected in the expression '{0}'.
+                <Parameter Type="System.String" Name="expression" />
+            </Instance>
+        </Message>
+        <Message Id="UnexpectedCustomTableColumn" Number="165">
+            <Instance>
+                The custom table column '{0}' is unknown.
+                <Parameter Type="System.String" Name="column" />
+            </Instance>
+        </Message>
+        <Message Id="UnknownCustomTableColumnType" Number="166">
+            <Instance>
+                Encountered an unknown custom table column type '{0}'.
+                <Parameter Type="System.String" Name="columnType" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalFileCompressionAttributes" Number="167">
+            <Instance>Cannot have both the MsidbFileAttributesCompressed and MsidbFileAttributesNoncompressed options set in a file attributes column.</Instance>
+        </Message>
+        <Message Id="OverridableActionCollision" Number="168">
+            <Instance>
+                The {0} table contains an action '{1}' that is declared overridable in two different locations.  Please remove one of the actions or the Overridable='yes' attribute from one of the actions.
+                <Parameter Type="System.String" Name="sequenceTableName" />
+                <Parameter Type="System.String" Name="actionName" />
+            </Instance>
+        </Message>
+        <Message Id="OverridableActionCollision2" Number="169">
+            <Instance>The location of the action related to previous error.</Instance>
+        </Message>
+        <Message Id="ActionCollision" Number="170">
+            <Instance>
+                The {0} table contains an action '{1}' that is declared in two different locations.  Please remove one of the actions or set the Overridable='yes' attribute on one of their elements.
+                <Parameter Type="System.String" Name="sequenceTableName" />
+                <Parameter Type="System.String" Name="actionName" />
+            </Instance>
+        </Message>
+        <Message Id="ActionCollision2" Number="171">
+            <Instance>The location of the action related to previous error.</Instance>
+        </Message>
+        <Message Id="SuppressNonoverridableAction" Number="172">
+            <Instance>
+                The {0} table contains an action '{1}' that cannot be suppressed because it is not declared overridable in the base definition.  Please stop suppressing the action or make it overridable in its base declaration.
+                <Parameter Type="System.String" Name="sequenceTableName" />
+                <Parameter Type="System.String" Name="actionName" />
+            </Instance>
+        </Message>
+        <Message Id="SuppressNonoverridableAction2" Number="173">
+            <Instance>The location of the non-overridable definition of the action related to previous error.</Instance>
+        </Message>
+        <Message Id="CustomActionSequencedInModule" Number="174">
+            <Instance>
+                The {0} table contains a custom action '{1}' that has a sequence number specified.  The Sequence attribute is not allowed for custom actions in a merge module.  Please remove the action or use the Before or After attributes to specify where this action should be sequenced relative to another action.
+                <Parameter Type="System.String" Name="sequenceTableName" />
+                <Parameter Type="System.String" Name="actionName" />
+            </Instance>
+        </Message>
+        <Message Id="StandardActionRelativelyScheduledInModule" Number="175">
+            <Instance>
+                The {0} table contains a standard action '{1}' that does not have a sequence number specified.  The Sequence attribute is required for standard actions in a merge module.  Please remove the action or use the Sequence attribute.
+                <Parameter Type="System.String" Name="sequenceTableName" />
+                <Parameter Type="System.String" Name="actionName" />
+            </Instance>
+        </Message>
+        <Message Id="ActionCircularDependency" Number="176">
+            <Instance>
+                The {0} table contains an action '{1}' that is scheduled to come before or after action '{2}', which is also scheduled to come before or after action '{1}'.  Please remove this circular dependency by changing the Before or After attribute for one of the actions.
+                <Parameter Type="System.String" Name="sequenceTableName" />
+                <Parameter Type="System.String" Name="actionName1" />
+                <Parameter Type="System.String" Name="actionName2" />
+            </Instance>
+        </Message>
+        <Message Id="ActionScheduledRelativeToTerminationAction" Number="177">
+            <Instance>
+                The {0} table contains an action '{1}' that is scheduled to come before or after action '{2}', which is a special action which only occurs when the installer terminates.  These special actions can be identified by their negative sequence numbers.  Please schedule the action '{1}' to come before or after a different action.
+                <Parameter Type="System.String" Name="sequenceTableName" />
+                <Parameter Type="System.String" Name="actionName1" />
+                <Parameter Type="System.String" Name="actionName2" />
+            </Instance>
+        </Message>
+        <Message Id="ActionScheduledRelativeToTerminationAction2" Number="178">
+            <Instance>The location of the special termination action related to previous error(s).</Instance>
+        </Message>
+        <Message Id="NoUniqueActionSequenceNumber" Number="179">
+            <Instance>
+                The {0} table contains an action '{1}' which cannot have a unique sequence number because it is scheduled before or after action '{2}'.  There is not enough room before or after this action to assign a unique sequence number.  Please schedule one of the actions differently so that it will be in a position with more sequence numbers available.  Please note that sequence numbers must be an integer in the range 1 - 32767 (inclusive).
+                <Parameter Type="System.String" Name="sequenceTableName" />
+                <Parameter Type="System.String" Name="actionName1" />
+                <Parameter Type="System.String" Name="actionName2" />
+            </Instance>
+        </Message>
+        <Message Id="NoUniqueActionSequenceNumber2" Number="180">
+            <Instance>The location of the sequenced action related to previous error.</Instance>
+        </Message>
+        <Message Id="ActionScheduledRelativeToItself" Number="181">
+            <Instance>
+                The {0}/@{1} attribute's value '{2}' is invalid because it would make this action dependent upon itself.  Please change the value to the name of a different action.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="attributeValue" />
+            </Instance>
+        </Message>
+        <Message Id="MissingTableDefinition" Number="182" SourceLineNumbers="no">
+            <Instance>
+                Cannot find the table definitions for the '{0}' table.  This is likely due to a typing error or missing extension.  Please ensure all the necessary extensions are supplied on the command line with the -ext parameter.
+                <Parameter Type="System.String" Name="tableName" />
+            </Instance>
+        </Message>
+        <Message Id="ExpectedRowInPatchCreationPackage" Number="183" SourceLineNumbers="no">
+            <Instance>
+                Could not find a row in the '{0}' table for this patch creation package.  Patch creation packages must contain at least one row in the '{0}' table.
+                <Parameter Type="System.String" Name="tableName" />
+            </Instance>
+        </Message>
+        <Message Id="UnexpectedTableInMergeModule" Number="184">
+            <Instance>
+                An unexpected row in the '{0}' table was found in this merge module.  Merge modules cannot contain the '{0}' table.
+                <Parameter Type="System.String" Name="tableName" />
+            </Instance>
+        </Message>
+        <Message Id="UnexpectedTableInPatchCreationPackage" Number="185">
+            <Instance>
+                An unexpected row in the '{0}' table was found in this patch creation package.  Patch creation packages cannot contain the '{0}' table.
+                <Parameter Type="System.String" Name="tableName" />
+            </Instance>
+        </Message>
+        <Message Id="MergeExcludedModule" Number="186">
+            <Instance>
+                The module '{0}' cannot be merged because it excludes or is excluded by the merge module with signature '{1}'.
+                <Parameter Type="System.String" Name="mergeId" />
+                <Parameter Type="System.String" Name="otherMergeId" />
+            </Instance>
+        </Message>
+        <Message Id="MergeFeatureRequired" Number="187">
+            <Instance>
+                The {0} table contains a row with primary key(s) '{1}' which requires a feature to properly merge from the merge module '{2}'.  Nest a MergeRef element with an Id attribute set to the value '{3}' under a Feature element to fix this error.
+                <Parameter Type="System.String" Name="tableName" />
+                <Parameter Type="System.String" Name="primaryKeys" />
+                <Parameter Type="System.String" Name="mergeModuleFile" />
+                <Parameter Type="System.String" Name="mergeId" />
+            </Instance>
+        </Message>
+        <Message Id="MergeLanguageFailed" Number="188">
+            <Instance>
+                The language '{0}' is supported but uses an invalid language transform in the merge module '{1}'.
+                <Parameter Type="System.Int16" Name="language" />
+                <Parameter Type="System.String" Name="mergeModuleFile" />
+            </Instance>
+        </Message>
+        <Message Id="MergeLanguageUnsupported" Number="189">
+            <Instance>
+                Could not locate language '{0}' (or a transform for this language) in the merge module '{1}'.  This is likely due to an incorrectly authored Merge/@Language attribute.
+                <Parameter Type="System.Int16" Name="language" />
+                <Parameter Type="System.String" Name="mergeModuleFile" />
+            </Instance>
+        </Message>
+        <Message Id="TableDecompilationUnimplemented" Number="190" SourceLineNumbers="no">
+            <Instance>
+                Decompilation of the {0} table has not been implemented by its extension.
+                <Parameter Type="System.String" Name="tableName" />
+            </Instance>
+        </Message>
+        <Message Id="CannotDefaultMismatchedAdvertiseStates" Number="191">
+            <Instance>
+                MIME element cannot be marked as the default when its advertise state differs from its parent element.  Ensure that the advertise state of the MIME element matches its parents element or remove the Mime/@Advertise attribute completely.
+            </Instance>
+        </Message>
+        <Message Id="VersionIndependentProgIdsCannotHaveIcons" Number="192">
+            <Instance>
+                Version independent ProgIds cannot have Icons.  Remove the Icon and/or IconIndex attributes from your ProgId element.
+            </Instance>
+        </Message>
+        <Message Id="IllegalAttributeValueWithOtherAttribute" Number="193">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', cannot be specified with attribute {3} present.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="attributeValue" />
+                <Parameter Type="System.String" Name="otherAttributeName" />
+            </Instance>
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', cannot be specified with attribute {3} present with value '{4}'.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="attributeValue" />
+                <Parameter Type="System.String" Name="otherAttributeName" />
+                <Parameter Type="System.String" Name="otherAttributeValue" />
+            </Instance>
+        </Message>
+        <Message Id="InvalidMergeLanguage" Number="194">
+            <Instance>
+                The Merge element '{0}' specified an invalid language '{1}'.  Verify that localization tokens are being properly resolved to a numeric LCID.
+                <Parameter Type="System.String" Name="mergeId" />
+                <Parameter Type="System.String" Name="mergeLanguage" />
+            </Instance>
+        </Message>
+        <Message Id="WixVariableCollision" Number="195">
+            <Instance>
+                The WiX variable '{0}' is declared in more than one location.  Please remove one of the declarations.
+                <Parameter Type="System.String" Name="variableId" />
+            </Instance>
+        </Message>
+        <Message Id="ExpectedWixVariableValue" Number="196" SourceLineNumbers="no">
+            <Instance>
+                The WiX variable '{0}' was declared without a value.  Please specify a value for the variable.
+                <Parameter Type="System.String" Name="variableId" />
+            </Instance>
+        </Message>
+        <Message Id="WixVariableUnknown" Number="197">
+            <Instance>
+                The WiX variable !(wix.{0}) is unknown.  Please ensure the variable is declared on the command line for light.exe, via a WixVariable element, or inline using the syntax !(wix.{0}=some value which doesn't contain parenthesis).
+                <Parameter Type="System.String" Name="variableId" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalWixVariablePrefix" Number="198">
+            <Instance>
+                The WiX variable $(wix.{0}) uses an illegal prefix '$'.  Please use the '!' prefix instead.
+                <Parameter Type="System.String" Name="variableId" />
+            </Instance>
+        </Message>
+        <Message Id="InvalidWixXmlNamespace" Number="199">
+            <Instance>
+                The {0} element has no namespace.  Please make the {0} element look like the following: &lt;{0} xmlns="{1}"&gt;.
+                <Parameter Type="System.String" Name="wixElementName" />
+                <Parameter Type="System.String" Name="wixNamespace" />
+            </Instance>
+            <Instance>
+                The {0} element has an incorrect namespace of '{1}'.  Please make the {0} element look like the following: &lt;{0} xmlns="{2}"&gt;.
+                <Parameter Type="System.String" Name="wixElementName" />
+                <Parameter Type="System.String" Name="elementNamespace" />
+                <Parameter Type="System.String" Name="wixNamespace" />
+            </Instance>
+        </Message>
+        <Message Id="UnhandledExtensionElement" Number="200">
+            <Instance>
+                The {0} element contains an unhandled extension element '{1}'.  Please ensure that the extension for elements in the '{2}' namespace has been provided.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="extensionElementName" />
+                <Parameter Type="System.String" Name="extensionNamespace" />
+            </Instance>
+        </Message>
+        <Message Id="UnhandledExtensionAttribute" Number="201">
+            <Instance>
+                The {0} element contains an unhandled extension attribute '{1}'.  Please ensure that the extension for attributes in the '{2}' namespace has been provided.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="extensionAttributeName" />
+                <Parameter Type="System.String" Name="extensionNamespace" />
+            </Instance>
+        </Message>
+        <Message Id="UnsupportedExtensionAttribute" Number="202">
+            <Instance>
+                The {0} element contains an unsupported extension attribute '{1}'.  The {0} element does not currently support extension attributes. Is the {1} attribute using the correct XML namespace?
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="extensionElementName" />
+            </Instance>
+        </Message>
+        <Message Id="UnsupportedExtensionElement" Number="203">
+            <Instance>
+                The {0} element contains an unsupported extension element '{1}'.  The {0} element does not currently support extension elements. Is the {1} element using the correct XML namespace?
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="extensionElementName" />
+            </Instance>
+        </Message>
+        <Message Id="ValidationError" Number="204">
+            <Instance>
+                {0}: {1}
+                <Parameter Type="System.String" Name="ice" />
+                <Parameter Type="System.String" Name="message" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalRootDirectory" Number="205">
+            <Instance>
+                The Directory with Id '{0}' is not a valid root directory.  There may only be a single root directory per product or module and its Id attribute value must be 'TARGETDIR' and its Name attribute value must be 'SourceDir'.
+                <Parameter Type="System.String" Name="directoryId" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalTargetDirDefaultDir" Number="206">
+            <Instance>
+                The 'TARGETDIR' directory has an illegal DefaultDir value of '{0}'.  The DefaultDir value is created from the *Name attributes of the Directory element.  The TARGETDIR directory is a special directory which must have its Name attribute set to 'SourceDir'.
+                <Parameter Type="System.String" Name="defaultDir" />
+            </Instance>
+        </Message>
+        <Message Id="TooManyElements" Number="207">
+            <Instance>
+                The {0} element contains an unexpected child element '{1}'.  The '{1}' element may only occur {2} time(s) under the {0} element.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="childElementName" />
+                <Parameter Type="System.Int32" Name="expectedInstances" />
+            </Instance>
+        </Message>
+        <Message Id="ExpectedBinaryCategory" Number="208">
+            <Instance>The Column element specifies a binary column but does not have the correct Category specified.  Windows Installer requires binary columns to specify their category as binary.  Please set the Category attribute's value to 'Binary'.</Instance>
+        </Message>
+        <Message Id="RootFeatureCannotFollowParent" Number="209">
+            <Instance>The Feature element specifies a root feature with an illegal InstallDefault value of 'followParent'.  Root features cannot follow their parent feature's install state because they don't have a parent feature.  Please remove or change the value of the InstallDefault attribute.</Instance>
+        </Message>
+        <Message Id="FeatureNameTooLong" Number="210">
+            <Instance>
+                The {0}/@{1} attribute with value '{2}', is too long for a feature name.  Due to limitations in the Windows Installer, feature names cannot be longer than 38 characters in length.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="attributeValue" />
+            </Instance>
+        </Message>
+        <Message Id="SignedEmbeddedCabinet" Number="211">
+            <Instance>The DigitalSignature element cannot be nested under a Media element which specifies EmbedCab='yes'.  This is because Windows Installer can only verify the digital signatures of external cabinets.  Please either remove the DigitalSignature element or change the value of the Media/@EmbedCab attribute to 'no'.</Instance>
+        </Message>
+        <Message Id="ExpectedSignedCabinetName" Number="212">
+            <Instance>The Media/@Cabinet attribute was not found; it is required when this element contains a DigitalSignature child element.  This is because Windows Installer can only verify the digital signatures of external cabinets.  Please either remove the DigitalSignature element or specify a valid external cabinet name via the Cabinet attribute.</Instance>
+        </Message>
+        <Message Id="IllegalInlineLocVariable" Number="213">
+            <Instance>
+                The localization variable '{0}' specifies an illegal inline default value of '{1}'.  Localization variables cannot specify default values inline, instead the value should be specified in a WiX localization (.wxl) file.
+                <Parameter Type="System.String" Name="variableName" />
+                <Parameter Type="System.String" Name="variableValue" />
+            </Instance>
+        </Message>
+        <Message Id="MergeModuleExpectedFeature" Number="215">
+            <Instance>
+                The merge module '{0}' is not assigned to a feature.  All merge modules must be assigned to at least one feature.
+                <Parameter Type="System.String" Name="mergeId" />
+            </Instance>
+        </Message>
+        <Message Id="Win32Exception" Number="216" SourceLineNumbers="no">
+            <Instance>
+                An unexpected Win32 exception with error code 0x{0:X} occurred: {1}
+                <Parameter Type="System.Int32" Name="nativeErrorCode"/>
+                <Parameter Type="System.String" Name="message" />
+            </Instance>
+            <Instance>
+                An unexpected Win32 exception with error code 0x{0:X} occurred while accessing file '{1}': {2}
+                <Parameter Type="System.Int32" Name="nativeErrorCode"/>
+                <Parameter Type="System.String" Name="file"/>
+                <Parameter Type="System.String" Name="message" />
+            </Instance>
+        </Message>
+        <Message Id="UnexpectedExternalUIMessage" Number="217" SourceLineNumbers="no">
+            <Instance>
+                Error executing unknown ICE action. The most common cause of this kind of ICE failure is an incorrectly registered scripting engine. See http://wixtoolset.org/documentation/error217/ for details and how to solve this problem. The following string format was not expected by the external UI message logger: &quot;{0}&quot;.
+                <Parameter Type="System.String" Name="message" />
+            </Instance>
+            <Instance>
+                Error executing ICE action '{1}'. The most common cause of this kind of ICE failure is an incorrectly registered scripting engine. See http://wixtoolset.org/documentation/error217/ for details and how to solve this problem. The following string format was not expected by the external UI message logger: &quot;{0}&quot;.
+                <Parameter Type="System.String" Name="message" />
+                <Parameter Type="System.String" Name="action" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalCabbingThreadCount" Number="218" SourceLineNumbers="no">
+            <Instance>
+                Illegal number of threads to create cabinets: '{0}' for -ct &lt;N&gt; command line option. Specify the number of threads to use like -ct 2.
+                <Parameter Type="System.String" Name="numThreads" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalEnvironmentVariable" Number="219" SourceLineNumbers="no">
+            <Instance>
+                The {0} environment variable is set to an invalid value of '{1}'.
+                <Parameter Type="System.String" Name="environmentVariable" />
+                <Parameter Type="System.String" Name="value" />
+            </Instance>
+        </Message>
+        <Message Id="InvalidKeyColumn" Number="220" SourceLineNumbers="no">
+            <Instance>
+                The definition for the '{0}' table's '{1}' column is an invalid foreign key relationship to the {2} table's column number {3}.  It is not a valid foreign key table column number because it is too small (less than 1) or greater than the count of columns in the foreign table's definition.
+                <Parameter Type="System.String" Name="tableName" />
+                <Parameter Type="System.String" Name="columnName" />
+                <Parameter Type="System.String" Name="foreignTableName" />
+                <Parameter Type="System.Int32" Name="foreignColumnNumber" />
+            </Instance>
+        </Message>
+        <Message Id="CollidingModularizationTypes" Number="221" SourceLineNumbers="no">
+            <Instance>
+                The definition for the '{0}' table's '{1}' column is a foreign key relationship to the '{2}' table's column number {3}.  The modularization types of the two column definitions differ: one is {4} and the other is {5}.  Change one of the modularization types so that they match.
+                <Parameter Type="System.String" Name="tableName" />
+                <Parameter Type="System.String" Name="columnName" />
+                <Parameter Type="System.String" Name="foreignTableName" />
+                <Parameter Type="System.Int32" Name="foreignColumnNumber" />
+                <Parameter Type="System.String" Name="modularizationType" />
+                <Parameter Type="System.String" Name="foreignModularizationType" />
+            </Instance>
+        </Message>
+        <Message Id="CubeFileNotFound" Number="222" SourceLineNumbers="no">
+            <Instance>
+                The cube file '{0}' cannot be found.  This file is required for MSI validation.
+                <Parameter Type="System.String" Name="cubeFile" />
+            </Instance>
+        </Message>
+        <Message Id="OpenDatabaseFailed" Number="223" SourceLineNumbers="no">
+            <Instance>
+                Failed to open database '{0}'.  Ensure it is a valid database, and it is not open by another process.
+                <Parameter Type="System.String" Name="databaseFile" />
+            </Instance>
+        </Message>
+        <Message Id="OutputTypeMismatch" Number="224">
+            <Instance>
+                The types of the outputs do not match.  One output's type is '{0}' while the other is '{1}'.
+                <Parameter Type="System.String" Name="beforeOutputType" />
+                <Parameter Type="System.String" Name="afterOutputType" />
+            </Instance>
+        </Message>
+        <Message Id="RealTableMissingPrimaryKeyColumn" Number="225">
+            <Instance>
+                The table '{0}' does not contain any primary key columns.  At least one column must be marked as the primary key to ensure this table can be patched.
+                <Parameter Type="System.String" Name="tableName" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalColumnName" Number="226">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is not a legal column name.  It will collide with the sentinel values used in the _TransformView table.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+            </Instance>
+        </Message>
+        <Message Id="NoDifferencesInTransform" Number="227">
+            <Instance>
+                The transform being built did not contain any differences so it could not be created.
+            </Instance>
+        </Message>
+        <Message Id="OutputCodepageMismatch" Number="228">
+            <Instance>
+                The code pages of the outputs do not match.  One output's code page is '{0}' while the other is '{1}'.
+                <Parameter Type="System.Int32" Name="beforeCodepage" />
+                <Parameter Type="System.Int32" Name="afterCodepage" />
+            </Instance>
+        </Message>
+        <Message Id="OutputCodepageMismatch2" Number="229">
+            <Instance>
+                The location of the mismatched code page related to the previous warning.
+            </Instance>
+        </Message>
+        <Message Id="IllegalComponentWithAutoGeneratedGuid" Number="230">
+            <Instance>
+                The Component/@Guid attribute's value '*' is not valid for this component because it does not meet the criteria for having an automatically generated guid. Components using a Directory as a KeyPath or containing ODBCDataSource child elements cannot use an automatically generated guid. Make sure your component doesn't have a Directory as the KeyPath and move any ODBCDataSource child elements to components with explicit component guids.
+            </Instance>
+            <Instance>
+                The Component/@Guid attribute's value '*' is not valid for this component because it does not meet the criteria for having an automatically generated guid. Components with registry keypaths and files cannot use an automatically generated guid. Create multiple components, each with one file and/or one registry value keypath, to use automatically generated guids.
+                <Parameter Type="System.Boolean" Name="registryKeyPath" />
+            </Instance>
+        </Message>
+      <Message Id="IllegalPathForGeneratedComponentGuid" Number="231">
+            <Instance>
+                The component '{0}' has a key file with path '{1}'.  Since this path is not rooted in one of the standard directories (like ProgramFilesFolder), this component does not fit the criteria for having an automatically generated guid.  (This error may also occur if a path contains a likely standard directory such as nesting a directory with name "Common Files" under ProgramFilesFolder.)
+                <Parameter Type="System.String" Name="componentName" />
+                <Parameter Type="System.String" Name="keyFilePath" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalTerminalServerCustomActionAttributes" Number="232">
+            <Instance>
+                The CustomAction/@TerminalServerAware attribute's value is 'yes' but the Execute attribute is not 'deferred,' 'rollback,' or 'commit.' Terminal-Server-aware custom actions must be deferred, rollback, or commit custom actions. For more information, see http://msdn.microsoft.com/library/aa372071.aspx."
+            </Instance>
+        </Message>
+        <Message Id="IllegalPropertyCustomActionAttributes" Number="233">
+            <Instance>
+                The CustomAction sets a property but its Execute attribute is not 'immediate' (the default). Property-setting custom actions cannot be deferred."
+            </Instance>
+        </Message>
+        <Message Id="InvalidPreprocessorFunction" Number="234">
+            <Instance>
+                Ill-formed preprocessor function '${0}'.  Functions must have a prefix (like 'fun.'), a name at least 1 character long, and matching opening and closing parentheses.
+                <Parameter Type="System.String" Name="variable" />
+            </Instance>
+        </Message>
+        <Message Id="UndefinedPreprocessorFunction" Number="235">
+            <Instance>
+                Undefined preprocessor function '$({0})'.
+                <Parameter Type="System.String" Name="variableName" />
+            </Instance>
+        </Message>
+        <Message Id="PreprocessorExtensionEvaluateFunctionFailed" Number="236">
+            <Instance>
+                In the preprocessor extension that handles prefix '{0}' while trying to call function '{1}({2})' and exception has occurred : {3}
+                <Parameter Type="System.String" Name="prefix" />
+                <Parameter Type="System.String" Name="function" />
+                <Parameter Type="System.String" Name="args" />
+                <Parameter Type="System.String" Name="message" />
+            </Instance>
+        </Message>
+        <Message Id="PreprocessorExtensionGetVariableValueFailed" Number="237">
+            <Instance>
+                In the preprocessor extension that handles prefix '{0}' while trying to get the value for variable '{1}' and exception has occured : {2}
+                <Parameter Type="System.String" Name="prefix" />
+                <Parameter Type="System.String" Name="variable" />
+                <Parameter Type="System.String" Name="message" />
+            </Instance>
+        </Message>
+        <Message Id="InvalidManifestContent" Number="238">
+            <Instance>
+                The manifest '{0}' does not have the required assembly/assemblyIdentity element.
+                <Parameter Type="System.String" Name="fileName" />
+            </Instance>
+        </Message>
+        <Message Id="InvalidWixTransform" Number="239" SourceLineNumbers="no">
+            <Instance>
+                The file '{0}' is not a valid WiX Transform.
+                <Parameter Type="System.String" Name="fileName" />
+            </Instance>
+        </Message>
+        <Message Id="UnexpectedFileExtension" Number="240" SourceLineNumbers="no">
+            <Instance>
+                The file '{0}' has an unexpected extension. Expected one of the following: '{1}'.
+                <Parameter Type="System.String" Name="fileName" />
+                <Parameter Type="System.String" Name="expectedExtensions" />
+            </Instance>
+        </Message>
+        <Message Id="UnexpectedTableInPatch" Number="241">
+            <Instance>
+                An unexpected row in the '{0}' table was found in this patch.  Patches cannot contain the '{0}' table.
+                <Parameter Type="System.String" Name="tableName" />
+            </Instance>
+        </Message>
+        <Message Id="InvalidProductVersion" Number="242">
+            <Instance>
+                Invalid product version '{0}'. Product version must have a major version less than 256, a minor version less than 256, and a build version less than 65536.
+                <Parameter Type="System.String" Name="version" />
+            </Instance>
+            <Instance>
+                Invalid product version '{0}' in package '{1}'. When included in a bundle, all product version fields in an MSI package must be less than 65536.
+                <Parameter Type="System.String" Name="version" />
+                <Parameter Type="System.String" Name="packagePath" />
+            </Instance>
+        </Message>
+        <Message Id="InvalidKeypathChange" Number="243">
+            <Instance>
+                Component '{0}' has a changed keypath in the transform '{1}'. Patches cannot change the keypath of a component.
+                <Parameter Type="System.String" Name="component" />
+                <Parameter Type="System.String" Name="transformPath" />
+            </Instance>
+        </Message>
+        <Message Id="MissingValidatorExtension" Number="244" SourceLineNumbers="no">
+            <Instance>
+                The validator requires at least one extension. Add "ValidatorExtension, Wix" for the default implementation.
+            </Instance>
+        </Message>
+        <Message Id="InvalidValidatorMessageType" Number="245" SourceLineNumbers="no">
+            <Instance>
+                Unknown validation message type '{0}'.
+                <Parameter Type="System.String" Name="type" />
+            </Instance>
+        </Message>
+        <Message Id="PatchWithoutTransforms" Number="246" SourceLineNumbers="no">
+            <Instance>
+                No transforms were provided to attach to the patch.
+            </Instance>
+        </Message>
+        <Message Id="SingleExtensionSupported" Number="247" SourceLineNumbers="no">
+            <Instance>
+                Multiple extensions were specified on the command line, only a single extension is supported.
+            </Instance>
+        </Message>
+        <Message Id="DuplicateTransform" Number="248" SourceLineNumbers="no">
+            <Instance>
+                The transform {0} was included twice on the command line. Each transform can be applied to a patch only once.
+                <Parameter Type="System.String" Name="transform" />
+            </Instance>
+        </Message>
+        <Message Id="BaselineRequired" Number="249" SourceLineNumbers="no">
+            <Instance>
+                No baseline was specified for one of the transforms specified. A baseline is required for all transforms in a patch.
+            </Instance>
+        </Message>
+        <Message Id="PreprocessorError" Number="250">
+            <Instance>
+                {0}
+                <Parameter Type="System.String" Name="message" />
+            </Instance>
+        </Message>
+        <Message Id="ExpectedArgument" Number="251" SourceLineNumbers="no">
+            <Instance>
+                {0} is expected to be followed by a value argument.
+                <Parameter Type="System.String" Name="argument" />
+            </Instance>
+        </Message>
+        <Message Id="PatchWithoutValidTransforms" Number="252" SourceLineNumbers="no">
+            <Instance>
+                No valid transforms were provided to attach to the patch. Check to make sure the transforms you passed on the command line have a matching baseline authored in the patch. Also, make sure there are differences between your target and upgrade.
+            </Instance>
+        </Message>
+        <Message Id="ExpectedDecompiler" Number="253" SourceLineNumbers="no">
+            <Instance>
+                No decompiler was provided. {0} requires a decompiler.
+                <Parameter Type="System.String" Name="identifier" />
+            </Instance>
+        </Message>
+        <Message Id="ExpectedTableInMergeModule" Number="254" SourceLineNumbers="no">
+            <Instance>
+                The table '{0}' was expected but was missing.
+                <Parameter Type="System.String" Name="identifier" />
+            </Instance>
+        </Message>
+        <Message Id="UnexpectedElementWithAttributeValue" Number="255">
+            <Instance>
+                The {0} element cannot have a child element '{1}' unless attribute '{2}' is set to '{3}'.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="childElementName" />
+                <Parameter Type="System.String" Name="attribute" />
+                <Parameter Type="System.String" Name="attributeValue" />
+            </Instance>
+            <Instance>
+                The {0} element cannot have a child element '{1}' unless attribute '{2}' is set to '{3}' or '{4}'.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="childElementName" />
+                <Parameter Type="System.String" Name="attribute" />
+                <Parameter Type="System.String" Name="attributeValue1" />
+                <Parameter Type="System.String" Name="attributeValue2" />
+            </Instance>
+        </Message>
+        <Message Id="ExpectedPatchIdInWixMsp" Number="256" SourceLineNumbers="no">
+            <Instance>
+                The WixMsp is missing the patch ID.
+            </Instance>
+        </Message>
+        <Message Id="ExpectedMediaRowsInWixMsp" Number="257" SourceLineNumbers="no">
+            <Instance>
+                The WixMsp has no media rows defined.
+            </Instance>
+        </Message>
+        <Message Id="WixFileNotFound" Number="258" SourceLineNumbers="no">
+            <Instance>
+                The file '{0}' cannot be found.
+                <Parameter Type="System.String" Name="file" />
+            </Instance>
+        </Message>
+        <Message Id="ExpectedClientPatchIdInWixMsp" Number="259" SourceLineNumbers="no">
+            <Instance>
+                The WixMsp is missing the client patch ID. Recompile the patch source files with the latest WiX toolset.
+            </Instance>
+        </Message>
+        <Message Id="NewRowAddedInTable" Number="260">
+            <Instance>
+                Product '{0}': Table '{1}' has a new row '{2}' added. This makes the patch not uninstallable.
+                <Parameter Type="System.String" Name="productCode" />
+                <Parameter Type="System.String" Name="tableName" />
+                <Parameter Type="System.String" Name="rowId" />
+            </Instance>
+        </Message>
+        <Message Id="PatchNotRemovable" Number="261" SourceLineNumbers="no">
+            <Instance>
+                This patch is not uninstallable. The 'Patch' element's attribute 'AllowRemoval' should be set to 'no'.
+            </Instance>
+        </Message>
+        <Message Id="PathTooLong" Number="262">
+            <Instance>
+                '{0}' is too long, the fully qualified file name must be less than 260 characters, and the directory name must be less than 248 characters.
+                <Parameter Type="System.String" Name="fileName" />
+            </Instance>
+        </Message>
+        <Message Id="FileTooLarge" Number="263">
+            <Instance>
+                '{0}' is too large, file size must be less than 2147483648.
+                <Parameter Type="System.String" Name="fileName" />
+            </Instance>
+        </Message>
+        <Message Id="InvalidPlatformParameter" Number="264" SourceLineNumbers="no">
+            <Instance>
+                The parameter '{0}' is missing or has an invalid value {1}.  Possible values are x86, x64, or ia64.
+                <Parameter Type="System.String" Name="name" />
+                <Parameter Type="System.String" Name="value" />
+            </Instance>
+        </Message>
+        <Message Id="InvalidPlatformValue" Number="265">
+            <Instance>
+                The Platform attribute has an invalid value {0}.  Possible values are x86, x64, or ia64.
+                <Parameter Type="System.String" Name="value" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalValidationArguments" Number="266" SourceLineNumbers="no">
+            <Instance>
+                You may only specify a single default type using -t or specify custom validation using -serr and -val.
+            </Instance>
+        </Message>
+        <Message Id="OrphanedComponent" Number="267">
+            <Instance>
+                Found orphaned Component '{0}'.  If this is a Product, every Component must have at least one parent Feature.  To include a Component in a Module, you must include it directly as a Component element of the Module element or indirectly via ComponentRef, ComponentGroup, or ComponentGroupRef elements.
+                <Parameter Type="System.String" Name="componentName" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalCommandlineArgumentCombination" Number="268" SourceLineNumbers="no">
+            <Instance>
+                '-{0}' cannot be specfied in combination with '-{1}'.
+                <Parameter Type="System.String" Name="arg1" />
+                <Parameter Type="System.String" Name="arg2" />
+            </Instance>
+        </Message>
+        <Message Id="ProductCodeInvalidForTransform" Number="269">
+            <Instance>
+                The value '*' is not valid for the ProductCode when used in a transform or in a patch. Copy the ProductCode from your target product MSI into the Product/@Id attribute value for your product authoring.
+            </Instance>
+        </Message>
+        <Message Id="InsertInvalidSequenceActionOrder" Number="270">
+            <Instance>
+                Invalid order of actions {1} and {2} in sequence table {0}. Action {3} must occur after {1} and before {2}, but {2} is currently sequenced after {1}. Please fix the ordering or explicitly supply a location for the action {3}.
+                <Parameter Type="System.String" Name="sequenceTableName" />
+                <Parameter Type="System.String" Name="actionNameBefore" />
+                <Parameter Type="System.String" Name="actionNameAfter" />
+                <Parameter Type="System.String" Name="actionNameNew" />
+            </Instance>
+        </Message>
+        <Message Id="InsertSequenceNoSpace" Number="271">
+            <Instance>
+                Not enough space exists to sequence action {3} in table {0}. It must be sequenced after {1} and before {2}, but those two actions are currently sequenced next to each other. Please move one of those actions to allow {3} to be inserted between them.
+                <Parameter Type="System.String" Name="sequenceTableName" />
+                <Parameter Type="System.String" Name="actionNameBefore" />
+                <Parameter Type="System.String" Name="actionNameAfter" />
+                <Parameter Type="System.String" Name="actionNameNew" />
+            </Instance>
+        </Message>
+        <Message Id="MissingManifestForWin32Assembly" Number="272">
+            <Instance>
+                File '{0}' is marked as a Win32 assembly but it refers to assembly manifest '{1}' that is not present in this product.
+                <Parameter Type="System.String" Name="file" />
+                <Parameter Type="System.String" Name="manifest" />
+            </Instance>
+        </Message>
+        <Message Id="UnableToOpenModule" Number="273">
+            <Instance>
+                Unable to open merge module '{0}'. Check to make sure the module language is correct. '{1}'
+                <Parameter Type="System.String" Name="modulePath" />
+                <Parameter Type="System.String" Name="message" />
+            </Instance>
+        </Message>
+        <Message Id="ExpectedAttributeWhenElementNotUnderElement" Number="274">
+            <Instance>
+                The '{0}/@{1}' attribute was not found; it is required when element '{0}' is not nested under a '{2}' element.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="parentElementName" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalIdentifierLooksLikeFormatted" Number="275">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is not a legal identifier. The {0}/@{1} attribute does not support formatted string values, such as property names enclosed in brackets ([LIKETHIS]). The value must be the identifier of another element, such as the Directory/@Id attribute value.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalCodepageAttribute" Number="276">
+            <Instance>
+                The code page '{0}' is not a valid Windows code page. Please check the {1}/@{2} attribute value in your source file.
+                <Parameter Type="System.String" Name="codepage" />
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalCompressionLevel" Number="277" SourceLineNumbers="no">
+            <Instance>
+                The compression level '{0}' is not valid. Valid values are 'none', 'low', 'medium', 'high', and 'mszip'.
+                <Parameter Type="System.String" Name="compressionLevel" />
+            </Instance>
+        </Message>
+        <Message Id="TransformSchemaMismatch" Number="278" SourceLineNumbers="no">
+            <Instance>The transform schema does not match the database schema. The transform may have been generated from a different database.</Instance>
+        </Message>
+        <Message Id="DatabaseSchemaMismatch" Number="279">
+            <Instance>
+                The table definition of '{0}' in the target database does not match the table definition in the updated database. A transform requires that the target database schema match the updated database schema.
+                <Parameter Type="System.String" Name="tableName" />
+            </Instance>
+        </Message>
+        <Message Id="ExpectedDirectoryGotFile" Number="280" SourceLineNumbers="no">
+            <Instance>
+                The {0} option requires a directory, but the provided path is a file: {1}
+                <Parameter Type="System.String" Name="option" />
+                <Parameter Type="System.String" Name="path" />
+            </Instance>
+        </Message>
+        <Message Id="ExpectedFileGotDirectory" Number="281" SourceLineNumbers="no">
+            <Instance>
+                The {0} option requires a file, but the provided path is a directory: {1}
+                <Parameter Type="System.String" Name="option" />
+                <Parameter Type="System.String" Name="path" />
+            </Instance>
+        </Message>
+        <Message Id="GacAssemblyNoStrongName" Number="282">
+            <Instance>
+                Assembly {0} in component {1} has no strong name and has been marked to be placed in the GAC. All assemblies installed to the GAC must have a valid strong name.
+                <Parameter Type="System.String" Name="assemblyName" />
+                <Parameter Type="System.String" Name="componentName" />
+            </Instance>
+        </Message>
+        <Message Id="FileWriteError" Number="283" SourceLineNumbers="no">
+            <Instance>
+                Error writing to the path: '{0}'. Error message: '{1}'
+                <Parameter Type="System.String" Name="path" />
+                <Parameter Type="System.String" Name="error" />
+            </Instance>
+        </Message>
+        <Message Id="InvalidCommandLineFileName" Number="284" SourceLineNumbers="no">
+            <Instance>
+                Invalid file name specified on the command line: '{0}'. Error message: '{1}'
+                <Parameter Type="System.String" Name="fileName" />
+                <Parameter Type="System.String" Name="error" />
+            </Instance>
+        </Message>
+        <Message Id="ExpectedParentWithAttribute" Number="285">
+            <Instance>
+                When the {0}/@{1} attribute is specified, the {0} element must be nested under a {2} element.
+                <Parameter Type="System.String" Name="parentElement" />
+                <Parameter Type="System.String" Name="attribute" />
+                <Parameter Type="System.String" Name="grandparentElement" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalWarningIdAsError" Number="286" SourceLineNumbers="no">
+            <Instance>
+                Illegal value '{0}' for the -wx&lt;N&gt; command line option. Specify a particular warning number, like '-wx6' to display the warning with ID 6 as an error, or '-wx' alone to suppress all warnings.
+                <Parameter Type="System.String" Name="warningId" />
+            </Instance>
+        </Message>
+        <Message Id="ExpectedAttributeOrElement" Number="287">
+            <Instance>
+                Element '{0}' missing attribute '{1}' or child element '{2}'. Exactly one of those is required.
+                <Parameter Type="System.String" Name="parentElement" />
+                <Parameter Type="System.String" Name="attribute" />
+                <Parameter Type="System.String" Name="childElement" />
+            </Instance>
+        </Message>
+        <Message Id="DuplicateVariableDefinition" Number="288" SourceLineNumbers="no">
+            <Instance>
+                The variable '{0}' with value '{1}' was previously declared with value '{2}'.
+                <Parameter Type="System.String" Name="variableName" />
+                <Parameter Type="System.String" Name="variableValue" />
+                <Parameter Type="System.String" Name="variableCollidingValue" />
+            </Instance>
+        </Message>
+        <Message Id="InvalidVariableDefinition" Number="289" SourceLineNumbers="no">
+            <Instance>
+                The variable definition '{0}' is not valid.  Variable definitions should be in the form -dname=value where the value is optional.
+                <Parameter Type="System.String" Name="variableDefinition" />
+            </Instance>
+        </Message>
+        <Message Id="DuplicateCabinetName" Number="290">
+            <Instance>
+                Duplicate cabinet name '{0}' found.
+                <Parameter Type="System.String" Name="cabinetName" />
+            </Instance>
+        </Message>
+        <Message Id="DuplicateCabinetName2" Number="291">
+            <Instance>
+                Duplicate cabinet name '{0}' error related to previous error.
+                <Parameter Type="System.String" Name="cabinetName" />
+            </Instance>
+        </Message>
+        <Message Id="InvalidAddedFileRowWithoutSequence" Number="292">
+            <Instance>
+                A row has been added to the File table with id '{1}' that does not have a sequence number assigned to it. Create your transform from a pair of msi's instead of xml outputs to get sequences assigned to your File table's rows.
+                <Parameter Type="System.String" Name="fileRowId" />
+            </Instance>
+        </Message>
+        <Message Id="DuplicateFileId" Number="293" SourceLineNumbers="no">
+            <Instance>
+                Multiple files with ID '{0}' exist. Windows Installer does not support file IDs that differ only by case. Change the file IDs to be unique.
+                <Parameter Type="System.String" Name="fileId" />
+            </Instance>
+        </Message>
+        <Message Id="FullTempDirectory" Number="294" SourceLineNumbers="no">
+            <Instance>
+                Unable to create temporary file. A common cause is that too many files that have names beginning with '{0}' are present. Delete any unneeded files in the '{1}' directory and try again.
+                <Parameter Type="System.String" Name="prefix" />
+                <Parameter Type="System.String" Name="directory" />
+            </Instance>
+        </Message>
+        <Message Id="CreateCabAddFileFailed" Number="296" SourceLineNumbers="no">
+            <Instance>
+                An error (E_FAIL) was returned while adding files to a CAB file. This most commonly happens when creating a CAB file 2 GB or larger. Either reduce the size of your installation package, raise Media/@CompressionLevel to a higher compression level, or split your installation package's files into more than one CAB file.
+            </Instance>
+        </Message>
+        <Message Id="CreateCabInsufficientDiskSpace" Number="297" SourceLineNumbers="no">
+            <Instance>
+                An error (ERROR_DISK_FULL) was returned while creating a CAB file. This means you have insufficient disk space - please clear more disk space and try this operation again.
+            </Instance>
+        </Message>
+        <Message Id="UnresolvedBindReference" Number="298" SourceLineNumbers="yes">
+            <Instance>
+                Unresolved bind-time variable {0}.
+                <Parameter Type="System.String" Name="BindRef" />
+            </Instance>
+        </Message>
+        <Message Id="GACAssemblyIdentityWarning" Number="299" SourceLineNumbers="yes">
+            <Instance>
+                The destination name of file '{0}' does not match its assembly name '{1}' in your authoring. This will cause an installation failure for this assembly, because it will be installed to the Global Assembly Cache. To fix this error, update File/@Name of file '{0}' to be the actual name of the assembly.
+                <Parameter Type="System.String" Name="fileName" />
+                <Parameter Type="System.String" Name="assemblyName" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalCharactersInPath" Number="300" SourceLineNumbers="no">
+            <Instance>
+                Illegal characters in path '{0}'. Ensure you provided a valid path to the file.
+                <Parameter Type="System.String" Name="pathName" />
+            </Instance>
+        </Message>
+        <Message Id="ValidationFailedToOpenDatabase" Number="301" SourceLineNumbers="no">
+            <Instance>
+                Failed to open the database. During validation, this most commonly happens when attempting to open a database using an unsupported code page or a file that is not a valid Windows Installer database. Please use a different code page in Module/@Codepage, Package/@SummaryCodepage, Product/@Codepage, or WixLocalization/@Codepage; or make sure you provide the path to a valid Windows Installer database.
+            </Instance>
+        </Message>
+        <Message Id="MustSpecifyOutputWithMoreThanOneInput" Number="302" SourceLineNumbers="no">
+            <Instance>
+                You must specify an output file using the "-o" or "-out" switch when you provide more than one input file.
+            </Instance>
+        </Message>
+        <Message Id="IllegalSearchIdForParentDepth" Number="303">
+            <Instance>
+                When the parent DirectorySearch/@Depth attribute is greater than 1 for the DirectorySearch '{1}', the FileSearch/@Id attribute must be absent for FileSearch '{0}' unless the parent DirectorySearch/@AssignToProperty attribute value is 'yes'. Remove the FileSearch/@Id attribute for '{0}' to resolve this issue.
+                <Parameter Type="System.String" Name="id" />
+                <Parameter Type="System.String" Name="parentId" />
+            </Instance>
+        </Message>
+        <Message Id="IdentifierTooLongError" Number="304">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is too long.  {0}/@{1} attribute's must be {3} characters long or less.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+                <Parameter Type="System.Int32" Name="maxLength" />
+            </Instance>
+        </Message>
+        <Message Id="InvalidRemoveComponent" Number="305">
+            <Instance>
+                Removing component '{0}' from feature '{1}' is not supported. Either the component was removed or the guid changed in the transform '{2}'. Add the component back, undo the change to the component guid, or remove the entire feature.
+                <Parameter Type="System.String" Name="component" />
+                <Parameter Type="System.String" Name="feature" />
+                <Parameter Type="System.String" Name="transformPath" />
+            </Instance>
+        </Message>
+        <Message Id="FinishCabFailed" Number="306" SourceLineNumbers="no">
+            <Instance>
+                An error (E_FAIL) was returned while finalizing a CAB file. This most commonly happens when creating a CAB file with more than 65535 files in it. Either reduce the number of files in your installation package or split your installation package's files into more than one CAB file using the Media element.
+            </Instance>
+        </Message>
+        <Message Id="InvalidExtensionType" Number="307" SourceLineNumbers="no">
+            <Instance>
+                Either '{1}' was not defined in the assembly or the type defined in extension '{0}' could not be loaded.
+                <Parameter Type="System.String" Name="extension" />
+                <Parameter Type="System.String" Name="attributeType" />
+            </Instance>
+            <Instance>
+                The extension type '{1}' in extension '{0}' does not inherit from the expected class '{2}'.
+                <Parameter Type="System.String" Name="extension" />
+                <Parameter Type="System.String" Name="className" />
+                <Parameter Type="System.String" Name="expectedType" />
+            </Instance>
+            <Instance>
+                The type '{1}' in extension '{0}' could not be loaded. Exception type '{2}' returned the following message: {3}
+                <Parameter Type="System.String" Name="extension" />
+                <Parameter Type="System.String" Name="className" />
+                <Parameter Type="System.String" Name="exceptionType" />
+                <Parameter Type="System.String" Name="exceptionMessage"/>
+            </Instance>
+        </Message>
+        <Message Id="ValidationFailedDueToMultilanguageMergeModule" Number="309" SourceLineNumbers="no">
+            <Instance>
+                Failed to open merge module for validation. The most common cause of this error is specifying that the merge module supports multiple languages (using the Package/@Languages attribute) but not including language-specific embedded transforms. To fix this error, make the merge module language-neutral, make it language-specific, embed language transforms as specified in the MSI SDK at http://msdn.microsoft.com/library/aa367799.aspx, or disable validation.
+            </Instance>
+        </Message>
+        <Message Id="ValidationFailedDueToInvalidPackage" Number="310" SourceLineNumbers="no">
+            <Instance>
+                Failed to open package for validation. The most common cause of this error is validating an x64 package on an x86 system. To fix this error, run validation on an x64 system or disable validation.
+            </Instance>
+        </Message>
+        <Message Id="InvalidStringForCodepage" Number="311">
+            <Instance>
+                A string was provided with characters that are not available in the specified database code page '{0}'. Either change these characters to ones that exist in the database's code page, or update the database's code page by modifying one of the following attributes: Product/@Codepage, Module/@Codepage, Patch/@Codepage, PatchCreation/@Codepage, or WixLocalization/@Codepage.
+                <Parameter Type="System.String" Name="codepage" />
+            </Instance>
+        </Message>
+        <Message Id="InvalidEmbeddedUIFileName" Number="312">
+            <Instance>
+                The EmbeddedUI/@Name attribute value, '{0}', does not contain an extension. Windows Installer will not load an embedded UI DLL without an extension. Include an extension or just omit the Name attribute so it defaults to the file name portion of the Source attribute value.
+                <Parameter Type="System.String" Name="codepage" />
+            </Instance>
+        </Message>
+        <Message Id="UniqueFileSearchIdRequired" Number="313">
+            <Instance>
+                The DirectorySearch element '{0}' requires that the child {1} element has a unique Id when the DirectorySearch/@AssignToProperty attribute is set to 'yes'.
+                <Parameter Type="System.String" Name="id" />
+                <Parameter Type="System.String" Name="elementName" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalAttributeValueWhenNested" Number="314">
+            <Instance>
+                The {0}/@{1} attribute value, '{2}', cannot be specified when the {0} element is nested underneath a {3} element.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="attrivuteValue" />
+                <Parameter Type="System.String" Name="parentElementName" />
+            </Instance>
+        </Message>
+        <Message Id="AdminImageRequired" Number="315" SourceLineNumbers="no">
+            <Instance>
+                Source information is required for the product '{0}'. If you ran torch.exe with both target and updated .msi files, you must first perform an administrative installation of both .msi files then pass -a when running torch.exe.
+                <Parameter Type="System.String" Name="productCode" />
+            </Instance>
+        </Message>
+        <Message Id="SamePatchBaselineId" Number="316">
+            <Instance>
+                The PatchBaseline/@Id attribute value '{0}' is a child of multiple Media elements. This prevents transforms from being resolved to distinct media. Change the PatchBaseline/@Id attribute values to be unique.
+                <Parameter Type="System.String" Name="id" />
+            </Instance>
+        </Message>
+        <Message Id="SameFileIdDifferentSource" Number="317">
+            <Instance>
+                Two different source paths '{1}' and '{2}' were detected for the same file identifier '{0}'. You must either author these under Media elements with different Id attribute values or in different patches.
+                <Parameter Type="System.String" Name="fileId" />
+                <Parameter Type="System.String" Name="sourcePath1" />
+                <Parameter Type="System.String" Name="sourcePath2" />
+            </Instance>
+        </Message>
+        <Message Id="HarvestSourceNotSpecified" Number="318" SourceLineNumbers="no">
+            <Instance>
+                A harvest source must be specified after the harvest type and can be followed by harvester arguments.
+            </Instance>
+        </Message>
+        <Message Id="OutputTargetNotSpecified" Number="319" SourceLineNumbers="no">
+            <Instance>
+                The '-out' or '-o' parameter must specify a file path.
+            </Instance>
+        </Message>
+        <Message Id="DuplicateCommandLineOptionInExtension" Number="320" SourceLineNumbers="no">
+            <Instance>
+                The command line option '{0}' has already been loaded by another Heat extension.
+                <Parameter Type="System.String" Name="switch" />
+            </Instance>
+        </Message>
+        <Message Id="HarvestTypeNotFound" Number="321" SourceLineNumbers="no">
+            <Instance>
+                The harvest type was not found in the list of loaded Heat extensions.
+            </Instance>
+            <Instance>
+                The harvest type '{0}' was specified. Harvest types cannot start with a '-'. Remove the '-' to specify a valid harvest type.
+                <Parameter Type="System.String" Name="harvestType" />
+            </Instance>
+        </Message>
+        <Message Id="BothUpgradeCodesRequired" Number="322" SourceLineNumbers="no">
+            <Instance>
+                Both the target and updated product authoring must define the Product/@UpgradeCode attribute if the transform validates the UpgradeCode (default). Either define the Product/@UpgradeCode attribute in both the target and updated authoring, or set the Validate/@UpgradeCode attribute to 'no' in the patch authoring.
+            </Instance>
+        </Message>
+        <Message Id="IllegalBinderClassName" Number="323" SourceLineNumbers="no">
+            <Instance>
+                Illegal binder class name specified for -binder command line option.
+            </Instance>
+        </Message>
+        <Message Id="SpecifiedBinderNotFound" Number="324" SourceLineNumbers="no">
+            <Instance>
+                The specified binder class '{0}' was not found in any extensions.
+                <Parameter Type="System.String" Name="binderClass" />
+            </Instance>
+        </Message>
+        <Message Id="CannotLoadBinderFileManager" Number="325" SourceLineNumbers="no">
+            <Instance>
+                Cannot load binder file manager: {0}. Light can only load one binder file manager and has already loaded binder file manager: {1}.
+                <Parameter Type="System.String" Name="binderFileManager" />
+                <Parameter Type="System.String" Name="currentBinderFileManager" />
+            </Instance>
+        </Message>
+        <Message Id="CannotLoadLinkerExtension" Number="326" SourceLineNumbers="no">
+            <Instance>
+                Cannot load linker extension: {0}. Light can only load one link extension and has already loaded link extension: {1}.
+                <Parameter Type="System.String" Name="linkerExtension" />
+                <Parameter Type="System.String" Name="currentLinkerExtension" />
+            </Instance>
+        </Message>
+        <Message Id="UnableToGetAuthenticodeCertOfFile" Number="327" SourceLineNumbers="no">
+            <Instance>
+                Unable to get the authenticode certificate of '{0}'.  More information: {1}
+                <Parameter Type="System.String" Name="filePath" />
+                <Parameter Type="System.String" Name="moreInformation" />
+            </Instance>
+        </Message>
+        <Message Id="UnableToGetAuthenticodeCertOfFileDownlevelOS" Number="328" SourceLineNumbers="no">
+            <Instance>
+                Unable to get the authenticode certificate of '{0}'. The cryptography API has limitations on Windows XP and Windows Server 2003.  More information: {1}
+                <Parameter Type="System.String" Name="filePath" />
+                <Parameter Type="System.String" Name="moreInformation" />
+            </Instance>
+        </Message>
+        <Message Id="ReadOnlyOutputFile" Number="329" SourceLineNumbers="no">
+            <Instance>
+                Unable to output to file '{0}' because it is marked as read-only.
+                <Parameter Type="System.String" Name="filePath" />
+            </Instance>
+        </Message>
+        <Message Id="CannotDefaultComponentId" Number="330">
+            <Instance>
+                The Component/@Id attribute was not found; it is required when there is no valid keypath to use as the default id value.
+            </Instance>
+        </Message>
+        <Message Id="ParentElementAttributeRequired" Number="331">
+            <Instance>
+                The parent {0} element is missing the {1} attribute that is required for the {2} child element.
+                <Parameter Type="System.String" Name="parentElement" />
+                <Parameter Type="System.String" Name="parentAttribute" />
+                <Parameter Type="System.String" Name="childElement" />
+            </Instance>
+        </Message>
+        <Message Id="PreprocessorExtensionPragmaFailed" Number="333">
+            <Instance>
+                Exception thrown while processing pragma '{0}'. The exception's message is: {1}
+                <Parameter Type="System.String" Name="pragma" />
+                <Parameter Type="System.String" Name="message" />
+            </Instance>
+        </Message>
+        <Message Id="InvalidPreprocessorPragma" Number="334">
+            <Instance>
+                Malformed preprocessor pragma '{0}'. Pragmas must have a prefix, a name of at least 1 character long, and be followed by optional arguments.
+                <Parameter Type="System.String" Name="variable" />
+            </Instance>
+        </Message>
+        <Message Id="SmokeUnknownFileExtension" Number="335" SourceLineNumbers="no">
+          <Instance>
+            Unknown input file format - expected a .msi or .msm file.
+          </Instance>
+        </Message>
+        <Message Id="SmokeUnsupportedFileExtension" Number="336" SourceLineNumbers="no">
+          <Instance>
+            Files with an extension of .msp are not currently supported.
+          </Instance>
+        </Message>
+        <Message Id="SmokeMalformedPath" Number="337" SourceLineNumbers="no">
+          <Instance>
+            Path contains one or more invalid characters.
+          </Instance>
+        </Message>
+        <Message Id="InvalidStubExe" Number="338" SourceLineNumbers="no">
+            <Instance>
+                Stub executable '{0}' is not a valid Win32 executable.
+                <Parameter Type="System.String" Name="filename" />
+            </Instance>
+        </Message>
+        <Message Id="StubMissingWixburnSection" Number="339" SourceLineNumbers="no">
+            <Instance>
+                Stub executable '{0}' does not contain a .wixburn data section.
+                <Parameter Type="System.String" Name="filename" />
+            </Instance>
+        </Message>
+        <Message Id="StubWixburnSectionTooSmall" Number="340" SourceLineNumbers="no">
+            <Instance>
+                Stub executable '{0}' .wixburn data section is too small to store the Burn container header.
+                <Parameter Type="System.String" Name="filename" />
+            </Instance>
+        </Message>
+        <Message Id="MissingBundleInformation" Number="341" SourceLineNumbers="no">
+            <Instance>
+                The Bundle is missing '{0}' data, and cannot continue.
+                <Parameter Type="System.String" Name="data" />
+            </Instance>
+        </Message>
+        <Message Id="UnexpectedGroupChild" Number="342" SourceLineNumbers="no">
+            <Instance>
+                A group parent ('{0}'/'{1}') had an unexpected child ('{2}'/'{3}').
+                <Parameter Type="System.String" Name="parentType" />
+                <Parameter Type="System.String" Name="parentId" />
+                <Parameter Type="System.String" Name="childType" />
+                <Parameter Type="System.String" Name="childId" />
+            </Instance>
+        </Message>
+        <Message Id="OrderingReferenceLoopDetected" Number="343">
+            <Instance>
+                A circular reference of ordering dependencies was detected. The infinite loop includes: {0}. Ordering dependency references must form a directed acyclic graph.
+                <Parameter Type="System.String" Name="loopList" />
+            </Instance>
+        </Message>
+        <Message Id="IdentifierNotFound" Number="344" SourceLineNumbers="no">
+            <Instance>
+                An expected identifier ('{1}', of type '{0}') was not found.
+                <Parameter Type="System.String" Name="type" />
+                <Parameter Type="System.String" Name="identifier" />
+            </Instance>
+        </Message>
+        <Message Id="MergePlatformMismatch" Number="345">
+            <Instance>
+                '{0}' is a 64-bit merge module but the product consuming it is 32-bit. 32-bit products can consume only 32-bit merge modules.
+                <Parameter Type="System.String" Name="mergeModuleFile" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalRelativeLongFilename" Number="346">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is not a valid relative long name because it contains illegal characters.  Legal relative long names contain no more than 260 characters and must contain at least one non-period character.  Any character except for the follow may be used: ? | &gt; &lt; : / * ".
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalAttributeValueWithLegalList" Number="347">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is not one of the legal options: {3}.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+                <Parameter Type="System.String" Name="legalValueList" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalAttributeValueWithIllegalList" Number="348">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is one of the illegal options: {3}.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+                <Parameter Type="System.String" Name="illegalValueList" />
+            </Instance>
+        </Message>
+
+        <Message Id="InvalidSummaryInfoCodePage" Number="349">
+            <Instance>
+                The code page '{0}' is invalid for summary information. You must specify an ANSI code page.
+                <Parameter Type="System.Int32" Name="codePage" />
+            </Instance>
+        </Message>
+        <Message Id="ValidationFailedDueToLowMsiEngine" Number="350" SourceLineNumbers="no">
+            <Instance>
+                The package being validated requires a higher version of Windows Installer than is installed on this machine. Validation cannot continue.
+            </Instance>
+        </Message>
+        <Message Id="DuplicateSourcesForOutput" Number="351" SourceLineNumbers="no">
+            <Instance>
+                Multiple source files ({0}) have resulted in the same output file '{1}'.  This is likely because the source files only differ in extension or path.  Rename the source files to avoid this problem.
+                <Parameter Type="System.String" Name="sourceList" />
+                <Parameter Type="System.String" Name="outputFile" />
+            </Instance>
+        </Message>
+        <Message Id="UnableToReadPackageInformation" Number="352">
+            <Instance>
+                Unable to read package '{0}'. {1}
+                <Parameter Type="System.String" Name="packagePath" />
+                <Parameter Type="System.String" Name="detailedErrorMessage" />
+            </Instance>
+        </Message>
+        <Message Id="MultipleFilesMatchedWithOutputSpecification" Number="353" SourceLineNumbers="no">
+            <Instance>
+                A per-source file output specification has been provided ('{0}'), but multiple source files match the source specification ({1}).  Specifying a unique output requires that only a single source file match.
+                <Parameter Type="System.String" Name="sourceSpecification" />
+                <Parameter Type="System.String" Name="sourceList" />
+            </Instance>
+        </Message>
+        <Message Id="InvalidBundle" Number="354" SourceLineNumbers="no">
+          <Instance>
+            Unable to read bundle executable '{0}'. This is not a valid WiX bundle.
+            <Parameter Type="System.String" Name="bundleExecutable" />
+          </Instance>
+        </Message>
+      <Message Id="BundleTooNew" Number="355" SourceLineNumbers="no">
+        <Instance>
+          Unable to read bundle executable '{0}', because this bundle was created with a newer version of WiX (bundle version '{1}'). You must use a newer version of WiX in order to read this bundle.
+          <Parameter Type="System.String" Name="bundleExecutable" />
+          <!-- we use a 64-bit field here because the field is really a 32-bit UInt,
+              but UInt gives a non-CLS-compliant warning.
+              So 64-bit makes sure we don't drop the last bit -->
+          <Parameter Type="System.Int64" Name="bundleVersion" />
+        </Instance>
+      </Message>
+      <Message Id="WrongFileExtensionForNumberOfInputs" Number="356" SourceLineNumbers="no">
+        <Instance>
+          The extension '{0}' on the input specified '{1}' does not match the number of inputs required to handle an input with this extension. Check if you are missing an input or have too many.
+          <Parameter Type="System.String" Name="inputExtension" />
+          <Parameter Type="System.String" Name="input" />
+        </Instance>
+      </Message>
+      <Message Id="MediaTableCollision" Number="357">
+        <Instance>
+          Only one of Media and MediaTemplate tables should be authored.
+        </Instance>
+      </Message>
+      <Message Id="InvalidCabinetTemplate" Number="358">
+        <Instance>
+          CabinetTemplate attribute's value '{0}' must contain '{{0}}' and should contain no more than 8 characters followed by an optional extension of no more than 3 characters.  Any character except for the follow may be used: \ ? | &gt; &lt; : / * " + , ; = [ ] (space).  The Windows Installer team has recommended following the 8.3 format for external cabinet files and any other naming scheme is officially unsupported (which means it is not guaranteed to work on all platforms).
+          <Parameter Type="System.String" Name="cabinetTemplate" />
+        </Instance>
+      </Message>
+      <Message Id="MaximumUncompressedMediaSizeTooLarge" Number="359">
+         <Instance>
+          '{0}' is too large. Reduce the size of maximum uncompressed media size.
+             <Parameter Type="System.Int32" Name="maximumUncompressedMediaSize" />
+          </Instance>
+      </Message>
+      <Message Id="CatalogVerificationFailed" Number="360" SourceLineNumbers="no">
+         <Instance>
+          File '{0}' could not be verified with a catalog file.
+             <Parameter Type="System.String" Name="fileName" />
+         </Instance>
+      </Message>
+      <Message Id="CatalogFileHashFailed" Number="361" SourceLineNumbers="no">
+         <Instance>
+          Could not get hash of file '{0}'.  Error: {2}.
+             <Parameter Type="System.String" Name="fileName" />
+             <Parameter Type="System.Int32" Name="errorCode" />
+         </Instance>
+      </Message>
+      <Message Id="ReservedNamespaceViolation" Number="362">
+        <Instance>
+          The {0}/@{1} attribute's value begins with the reserved prefix '{2}'. Some prefixes are reserved by the Windows Installer and WiX toolset for well-known values. Change your attribute's value to not begin with the same prefix.
+          <Parameter Type="System.String" Name="element" />
+          <Parameter Type="System.String" Name="attribute" />
+          <Parameter Type="System.String" Name="prefix" />
+        </Instance>
+      </Message>
+      <Message Id="PerUserButAllUsersEquals1" Number="363">
+        <Instance>
+          The MSI '{0}' is explicitly marked to not elevate so it must be a per-user package but the ALLUSERS Property is set to '1' creating a per-machine package. Remove the Property with Id='ALLUSERS' and use Package/@InstallScope attribute to be explicit instead.
+          <Parameter Type="System.String" Name="path" />
+        </Instance>
+      </Message>
+      <Message Id="UnsupportedAllUsersValue" Number="364">
+        <Instance>
+          The MSI '{0}' set the ALLUSERS Property to '{0}' which is not supported. Remove the Property with Id='ALLUSERS' and use Package/@InstallScope attribute instead.
+          <Parameter Type="System.String" Name="path" />
+          <Parameter Type="System.String" Name="value" />
+        </Instance>
+      </Message>
+      <Message Id="DisallowedMsiProperty" Number="365">
+        <Instance>
+          The '{0}' MsiProperty is controlled by the bootstrapper and cannot be authored. (Illegal properties are: {1}.) Remove the MsiProperty element.
+          <Parameter Type="System.String" Name="property" />
+          <Parameter Type="System.String" Name="illegalValueList" />
+        </Instance>
+      </Message>
+      <Message Id="MissingOrInvalidModuleInstallerVersion" Number="366">
+        <Instance>
+          The merge module '{0}' from file '{1}' is either missing or has an invalid installer version. The value read from the installer version in module's summary information was '{2}'. This should be a numeric value representing a valid installer version such as 200 or 301.
+          <Parameter Type="System.String" Name="moduleId" />
+          <Parameter Type="System.String" Name="mergeModuleFile" />
+          <Parameter Type="System.String" Name="productInstallerVersion" />
+        </Instance>
+      </Message>
+      <Message Id="IllegalGeneratedGuidComponentUnversionedKeypath" Number="367">
+        <Instance>
+          The Component/@Guid attribute's value '*' is not valid for this component because it does not meet the criteria for having an automatically generated guid. Components with more than one file cannot use an automatically generated guid unless a versioned file is the keypath and the other files are unversioned. This component's keypath is not versioned. Create multiple components to use automatically generated guids.
+        </Instance>
+      </Message>
+      <Message Id="IllegalGeneratedGuidComponentVersionedNonkeypath" Number="368">
+        <Instance>
+          The Component/@Guid attribute's value '*' is not valid for this component because it does not meet the criteria for having an automatically generated guid. Components with more than one file cannot use an automatically generated guid unless a versioned file is the keypath and the other files are unversioned. This component has a non-keypath file that is versioned. Create multiple components to use automatically generated guids.
+        </Instance>
+      </Message>
+      <Message Id="DuplicateComponentGuids" Number="369">
+        <Instance>
+          Component/@Id='{0}' has a @Guid value '{1}' that duplicates another component in this package. It is recommended to give each component its own unique GUID.
+          <Parameter Type="System.String" Name="componentId" />
+          <Parameter Type="System.String" Name="guid" />
+        </Instance>
+      </Message>
+      <Message Id="DuplicateProviderDependencyKey" Number="370" SourceLineNumbers="no">
+        <Instance>
+          The provider dependency key '{0}' was already imported from the package with Id '{1}'. Please remove the Provides element with the key '{0}' from the package authoring.
+          <Parameter Type="System.String" Name="providerKey" />
+          <Parameter Type="System.String" Name="packageId" />
+        </Instance>
+      </Message>
+      <Message Id="MissingDependencyVersion" Number="371" SourceLineNumbers="no">
+        <Instance>
+          The provider dependency version was not authored for the package with Id '{0}'. Please author the Provides/@Version attribute for this package.
+          <Parameter Type="System.String" Name="packageId" />
+        </Instance>
+      </Message>
+
+      <Message Id="UnexpectedElementWithAttribute" Number="372">
+        <Instance>
+          The {0} element cannot have a child element '{1}' when attribute '{2}' is set.
+          <Parameter Type="System.String" Name="elementName" />
+          <Parameter Type="System.String" Name="childElementName" />
+          <Parameter Type="System.String" Name="attribute" />
+        </Instance>
+      </Message>
+      <Message Id="ExpectedAttributeWithElement" Number="373">
+        <Instance>
+          The {0} element must have attribute '{1}' when child element '{2}' is present.
+          <Parameter Type="System.String" Name="elementName" />
+          <Parameter Type="System.String" Name="attribute" />
+          <Parameter Type="System.String" Name="childElementName" />
+        </Instance>
+      </Message>
+      <Message Id="DuplicatedUiLocalization" Number="374">
+        <Instance>
+          The localization for control {0} in dialog {1} is duplicated. Only one localization per control is allowed.
+          <Parameter Type="System.String" Name="controlName" />
+          <Parameter Type="System.String" Name="dialogName" />
+        </Instance>
+        <Instance>
+          The localization for dialog {0} is duplicated. Only one localization per dialog is allowed.
+          <Parameter Type="System.String" Name="dialogName" />
+        </Instance>
+      </Message>
+      <Message Id="MaximumCabinetSizeForLargeFileSplittingTooLarge" Number="375">
+        <Instance>
+            '{0}' is too large. Reduce the size of maximum cabinet size for large file splitting. The maximum permitted value is '{1}' MB.
+            <Parameter Type="System.Int32" Name="maximumCabinetSizeForLargeFileSplitting" />
+            <Parameter Type="System.Int32" Name="maxValueOfMaxCabSizeForLargeFileSplitting" />
+        </Instance>
+      </Message>
+      <Message Id="SplitCabinetCopyRegistrationFailed" Number="376" SourceLineNumbers="no">
+        <Instance>
+          Failed to register the copy command for cabinet '{0}' formed by splitting cabinet '{1}'.
+          <Parameter Type="System.String" Name="newCabName" />
+          <Parameter Type="System.String" Name="firstCabName" />
+        </Instance>
+      </Message>
+      <Message Id="SplitCabinetNameCollision" Number="377" SourceLineNumbers="no">
+        <Instance>
+          The cabinet name '{0}' collides with the new cabinet formed by splitting cabinet '{1}', consider renaming cabinet '{0}'.
+          <Parameter Type="System.String" Name="newCabName" />
+          <Parameter Type="System.String" Name="firstCabName" />
+        </Instance>
+      </Message>
+      <Message Id="SplitCabinetInsertionFailed" Number="378" SourceLineNumbers="no">
+        <Instance>
+            Could not find the last split cabinet '{2}' in the Media Table. So failed to add new cabinet '{0}' formed by splitting cabinet '{1}' to the installer package.
+            <Parameter Type="System.String" Name="newCabName" />
+          <Parameter Type="System.String" Name="firstCabName" />
+          <Parameter Type="System.String" Name="lastCabinetOfThisSequence" />
+        </Instance>
+      </Message>
+      <Message Id="InvalidPreprocessorFunctionAutoVersion" Number="379">
+        <Instance>
+          Invalid AutoVersion template specified.
+        </Instance>
+      </Message>
+      <Message Id="InvalidModuleOrBundleVersion" Number="380">
+        <Instance>
+          Invalid {0}/@Version '{1}'. {0} version has a max value of "65535.65535.65535.65535" and must be all numeric.
+          <Parameter Type="System.String" Name="moduleOrBundle" />
+          <Parameter Type="System.String" Name="version" />
+        </Instance>
+      </Message>
+      <Message Id="UnsupportedPlatformForElement" Number="381">
+        <Instance>
+          The element {1} does not support platform '{0}'. Consider removing the element or using the preprocessor to conditionally include the element based on the platform.
+          <Parameter Type="System.String" Name="platform" />
+          <Parameter Type="System.String" Name="elementName" />
+        </Instance>
+      </Message>
+      <Message Id="MissingMedia" Number="382">
+        <Instance>
+          There is no media defined for disk id '{0}'. You must author either &lt;Media Id='{0}' ...&gt; or &lt;MediaTemplate ...&gt;.
+          <Parameter Type="System.Int32" Name="diskId" />
+        </Instance>
+      </Message>
+      <Message Id="RemotePayloadUnsupported" Number="383">
+        <Instance>
+          The RemotePayload element can only be used for ExePackage and MsuPackage payloads.
+        </Instance>
+      </Message>
+      <Message Id="IllegalYesNoAlwaysValue" Number="384">
+          <Instance>
+              The {0}/@{1} attribute's value, '{2}', is not a legal yes/no/always value.  The only legal values are 'always', 'no' or 'yes'.
+              <Parameter Type="System.String" Name="elementName" />
+              <Parameter Type="System.String" Name="attributeName" />
+              <Parameter Type="System.String" Name="value" />
+          </Instance>
+      </Message>
+      <Message Id="TooDeeplyIncluded" Number="385">
+        <Instance>
+          Include files cannot be nested more deeply than {0} times. Make sure included files don't accidentally include themselves.
+          <Parameter Type="System.Int32" Name="depth" />
+        </Instance>
+      </Message>
+      <Message Id="InlineDirectorySyntaxRequiresPath" Number="387">
+        <Instance>
+          The {0}/@{1} attribute's value '{2}' only specifies a directory reference. The inline directory syntax requires that at least one directory be specified in addition to the value. For example, use '{3}:\foo\' to add a 'foo' directory.
+          <Parameter Type="System.String" Name="elementName" />
+          <Parameter Type="System.String" Name="attributeName" />
+          <Parameter Type="System.String" Name="value" />
+          <Parameter Type="System.String" Name="identifier" />
+        </Instance>
+      </Message>
+      <Message Id="InsecureBundleFilename" Number="388" SourceLineNumbers="no">
+        <Instance>
+          The file name '{0}' creates an insecure bundle. Windows will load unnecessary compatibility shims into a bundle with that file name. These compatibility shims can be DLL hijacked allowing attackers to compromise your customers' computer. Choose a different bundle file name.
+          <Parameter Type="System.String" Name="filename" />
+        </Instance>
+      </Message>
+      <Message Id="PayloadMustBeRelativeToCache" Number="389">
+        <Instance>
+          The {0}/@{1} attribute's value, '{2}', is not a legal path name: Payload names must be relative to their cache directory and cannot contain '..'.
+          <Parameter Type="System.String" Name="elementName" />
+          <Parameter Type="System.String" Name="attributeName" />
+          <Parameter Type="System.String" Name="attributeValue" />
+        </Instance>
+      </Message>
+      <Message Id="MsiTransactionX86BeforeX64" Number="390">
+        <Instance>
+          MSI transactions must install all x64 packages before any x86 package.
+        </Instance>
+      </Message>
+    </Class>
+
+    <Class Name="WixWarnings" ContainerName="WixWarningEventArgs" BaseContainerName="MessageEventArgs" Level="Warning">
+        <Message Id="IdentifierCannotBeModularized" Number="1000">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is {3} characters long.  It will be too long if modularized.  The identifier shouldn't be longer than {4} characters long to allow for modularization (appending a guid for merge modules).
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="identifier" />
+                <Parameter Type="System.Int32" Name="length" />
+                <Parameter Type="System.Int32" Name="maximumLength" />
+            </Instance>
+        </Message>
+        <Message Id="EmptyAttributeValue" Number="1001">
+            <Instance>
+                The {0}/@{1} attribute's value cannot be an empty string.  If you want the value to be null or empty, simply remove the entire attribute.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+            </Instance>
+        </Message>
+        <Message Id="UnableToFindFileFromCabOrImage" Number="1002">
+            <Instance>
+                Unable to find existing file {0} to place in src location {1}.  Will likely cause a linker break.
+                <Parameter Type="System.String" Name="existingFileSpec" />
+                <Parameter Type="System.String" Name="srcFileSpec" />
+            </Instance>
+        </Message>
+        <Message Id="CopyFileFileIdUseless" Number="1003">
+            <Instance>Since the CopyFile/@FileId attribute was specified but none of the following attributes (DestinationName, DestinationDirectory, DestinationProperty) were specified, this authoring will not do anything.</Instance>
+        </Message>
+        <Message Id="NestedInstall" Number="1004">
+            <Instance>
+                The {0}.{1} column's value, '{2}', indicates a nested install.  Nested installations are not supported by the WiX team.  This action will be left out of the decompiled output.
+                <Parameter Type="System.String" Name="tableName" />
+                <Parameter Type="System.String" Name="columnName" />
+                <Parameter Type="System.Object" Name="value" />
+            </Instance>
+        </Message>
+        <Message Id="OrphanedProgId" Number="1005">
+            <Instance>
+                ProgId '{0}' is orphaned.  It has no associated component, so it will never install.  Every ProgId should have either a parent Class element or child Extension element (at any distance).
+                <Parameter Type="System.String" Name="progId" />
+            </Instance>
+        </Message>
+        <Message Id="PropertyUseless" Number="1006">
+            <Instance>
+                Property '{0}' does not contain a Value attribute and is not marked as Admin, Secure, or Hidden.  The Property element is being ignored.
+                <Parameter Type="System.String" Name="id" />
+            </Instance>
+        </Message>
+        <Message Id="RemoveFileNameRequired" Number="1007">
+            <Instance>The RemoveFile/@Name attribute will soon become required.  In order to match the old functionality of not specifying this attribute, please use the new RemoveFolder element instead.</Instance>
+        </Message>
+        <Message Id="SuppressAction" Number="1008">
+            <Instance>
+                The action '{0}' in the {1} table is being suppressed.
+                <Parameter Type="System.String" Name="action" />
+                <Parameter Type="System.String" Name="sequenceName" />
+            </Instance>
+        </Message>
+        <Message Id="SuppressMergedAction" Number="1009" SourceLineNumbers="no">
+            <Instance>
+                The merged action '{0}' in the {1} table is being suppressed.
+                <Parameter Type="System.String" Name="action" />
+                <Parameter Type="System.String" Name="sequenceName" />
+            </Instance>
+        </Message>
+        <Message Id="TargetDirCorrectedDefaultDir" Number="1010" SourceLineNumbers="no">
+            <Instance>
+                The Directory with Id 'TARGETDIR' must have the value 'SourceDir' in its 'DefaultDir' column. This has been automatically corrected for you in the decompiled output.
+            </Instance>
+        </Message>
+        <Message Id="AccessDeniedForDeletion" Number="1011">
+            <Instance>
+                Access denied; cannot delete '{0}'.
+                <Parameter Type="System.String" Name="tempFilesBasePath" />
+            </Instance>
+        </Message>
+        <Message Id="DirectoryInUse" Number="1012">
+            <Instance>
+                The directory '{0}' is in use and cannot be deleted.
+                <Parameter Type="System.String" Name="filePath" />
+            </Instance>
+        </Message>
+        <Message Id="AccessDeniedForSettingAttributes" Number="1013">
+            <Instance>
+                Access denied; cannot set attributes on '{0}'.
+                <Parameter Type="System.String" Name="filePath" />
+            </Instance>
+        </Message>
+        <Message Id="UnknownAction" Number="1024">
+            <Instance>
+                The {0} table contains an action '{1}' which is not a known custom action, dialog, or standard action.  This action will be left out of the decompiled output.
+                <Parameter Type="System.String" Name="sequenceTableName" />
+                <Parameter Type="System.String" Name="actionName" />
+            </Instance>
+        </Message>
+        <Message Id="IdentifierTooLong" Number="1026">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is too long for an identifier.  Standard identifiers are 72 characters long or less.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+            </Instance>
+        </Message>
+        <Message Id="UnknownPermission" Number="1030">
+            <Instance>
+                The {0} table contains a row with primary key '{1}' which has an unknown permission at bit {2}.
+                <Parameter Type="System.String" Name="tableName" />
+                <Parameter Type="System.String" Name="primaryKey" />
+                <Parameter Type="System.Int32" Name="bitPosition" />
+            </Instance>
+        </Message>
+        <Message Id="DirectoryRedundantNames" Number="1031">
+            <Instance>
+                The {0} element's {1} and {2} values are both '{3}'.  This is redundant; the {2} attribute should be removed.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="shortNameAttributeName" />
+                <Parameter Type="System.String" Name="longNameAttributeName" />
+                <Parameter Type="System.String" Name="attributeValue" />
+            </Instance>
+            <Instance>
+                The {0} element's source and destination names are identical.  This is redundant; the {1} and {2} attributes should be removed if present.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="sourceNameAttributeName" />
+                <Parameter Type="System.String" Name="longSourceAttributeName" />
+            </Instance>
+        </Message>
+        <Message Id="UnableToResetAcls" Number="1032" SourceLineNumbers="no">
+            <Instance>Unable to reset acls on destination files.</Instance>
+        </Message>
+        <Message Id="MediaExternalCabinetFilenameIllegal" Number="1033">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is not a valid external cabinet name.  Legal cabinet names should follow 8.3 format: they should contain no more than 8 characters followed by an optional extension of no more than 3 characters.  Any character except for the following may be used: \ ? | &gt; &lt; : / * " + , ; = [ ] (space).  The Windows Installer team has recommended following the 8.3 format for external cabinet files and any other naming scheme is officially unsupported (which means it is not guaranteed to work on all platforms).
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+            </Instance>
+        </Message>
+        <Message Id="DeprecatedPreProcVariable" Number="1034">
+            <Instance>
+                The built-in preprocessor variable '{0}' is deprecated.  Please correct your authoring to use the new '{1}' preprocessor variable instead.
+                <Parameter Type="System.String" Name="oldName" />
+                <Parameter Type="System.String" Name="newName" />
+            </Instance>
+        </Message>
+        <Message Id="FileSearchFileNameIssue" Number="1043">
+            <Instance>
+                The {0} element's {1} and {2} attributes were found.  Due to a bug with the Windows Installer, only the Name or LongName attribute should be used.  Use the Name attribute for 8.3 compliant file names and the LongName attribute for longer ones.  When using only the LongName attribute, ICE03 should be ignored for the Signature table's FileName column.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName1" />
+                <Parameter Type="System.String" Name="attributeName2" />
+            </Instance>
+        </Message>
+        <Message Id="AmbiguousFileOrDirectoryName" Number="1044">
+            <Instance>
+                The {0}/@{1} attribute's value '{2}' is an ambiguous short name because it ends with a '~' character followed by a number.  Under some circumstances, this name could resolve to more than one file or directory name and lead to unpredictable results (for example 'MICROS~1' may correspond to 'Microsoft Shared' or 'Microsoft Foo' or literally 'Micros~1').
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+            </Instance>
+        </Message>
+        <Message Id="PossiblyIncorrectTypelibVersion" Number="1048">
+            <Instance>
+                The Typelib table entry with Id '{0}' could have an incorrect version of '256.0'.  InstallShield has a bug relating to the Typelib Version column: it will incorrectly set the value '65536' in to represent version '1.0'.  However, this number actually corresponds to version '256.0'.  This bug will not affect the typelib version that is registered during installation, however, it will prevent the Windows Installer from correctly identifying whether a typelib is already installed and lead to unnecessary reinstallations of the typelib.
+                <Parameter Type="System.String" Name="id" />
+            </Instance>
+        </Message>
+        <Message Id="ImplicitComponentPrimaryFeature" Number="1049" SourceLineNumbers="no">
+            <Instance>
+                The component '{0}' does not have an explicit primary feature parent specified.  If the source files are linked in a different order, the primary parent feature may change.  To prevent accidental changes, the primary feature parent should be set to 'yes' in one of the ComponentRef/@Primary, ComponentGroupRef/@Primary, or FeatureGroupRef/@Primary locations for this component.
+                <Parameter Type="System.String" Name="componentId" />
+            </Instance>
+        </Message>
+        <Message Id="ActionSequenceCollision" Number="1050">
+            <Instance>
+                The {0} table contains actions '{1}' and '{2}' which both have the same sequence number {3}.  Please change the sequence number for one of these actions to avoid an ICE warning.
+                <Parameter Type="System.String" Name="sequenceTableName" />
+                <Parameter Type="System.String" Name="actionName1" />
+                <Parameter Type="System.String" Name="actionName2" />
+                <Parameter Type="System.Int32" Name="sequenceNumber" />
+            </Instance>
+        </Message>
+        <Message Id="ActionSequenceCollision2" Number="1051">
+            <Instance>The location of the action related to previous warning.</Instance>
+        </Message>
+        <Message Id="SuppressAction2" Number="1052">
+            <Instance>The location of the suppressed action related to previous warning.</Instance>
+        </Message>
+        <Message Id="UnexpectedTableInProduct" Number="1053">
+            <Instance>
+                An unexpected row in the '{0}' table was found in this product.  Products should not contain the '{0}' table.
+                <Parameter Type="System.String" Name="tableName" />
+            </Instance>
+        </Message>
+        <Message Id="DeprecatedAttribute" Number="1054">
+            <Instance>
+                The {0}/@{1} attribute has been deprecated.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+            </Instance>
+            <Instance>
+                The {0}/@{1} attribute has been deprecated.  Please use the {2} attribute instead.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="newAttributeName" />
+            </Instance>
+            <Instance>
+                The {0}/@{1} attribute has been deprecated.  Please use the {2} or {3} attribute instead.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="newAttributeName1" />
+                <Parameter Type="System.String" Name="newAttributeName2" />
+            </Instance>
+        </Message>
+        <Message Id="MergeRescheduledAction" Number="1055">
+            <Instance>
+                The {0} table contains an action '{1}' which cannot be merged from the merge module '{2}'.  This action is likely colliding with an action in the database that is being created.  The colliding action may have been authored in the database or merged in from another merge module.  If this is a standard action, it is likely colliding due to a difference in the condition for the action in the database and merge module.  If this is a custom action, it should only be declared in the database or one merge module.
+                <Parameter Type="System.String" Name="tableName" />
+                <Parameter Type="System.String" Name="actionName" />
+                <Parameter Type="System.String" Name="mergeModuleFile" />
+            </Instance>
+        </Message>
+        <Message Id="MergeTableFailed" Number="1056">
+            <Instance>
+                The {0} table contains a row with primary key(s) '{1}' which cannot be merged from the merge module '{2}'.  This is likely due to collision of rows with the same primary key(s) (but other different values in other columns) between the database and the merge module.
+                <Parameter Type="System.String" Name="tableName" />
+                <Parameter Type="System.String" Name="primaryKeys" />
+                <Parameter Type="System.String" Name="mergeModuleFile" />
+            </Instance>
+        </Message>
+        <Message Id="DecompiledStandardActionRelativelyScheduledInModule" Number="1057">
+            <Instance>
+                The {0} table contains a standard action '{1}' that does not have a sequence number specified.  A value in the Sequence column is required for standard actions in a merge module.  Remove the action from the decompiled authoring to have WiX automatically sequence it.
+                <Parameter Type="System.String" Name="sequenceTableName" />
+                <Parameter Type="System.String" Name="actionName" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalActionInSequence" Number="1058">
+            <Instance>
+                The {0} table contains an action '{1}' which is not allowed in this table.  If this is a standard action then it is not valid for this table, if it is a custom action or dialog then this table does not accept actions of that type.  This action will be left out of the decompiled output.
+                <Parameter Type="System.String" Name="sequenceTableName" />
+                <Parameter Type="System.String" Name="actionName" />
+            </Instance>
+        </Message>
+        <Message Id="ExpectedForeignRow" Number="1059">
+            <Instance>
+                The {0} table contains a row with primary key(s) '{1}' whose {2} column contains a value, '{3}', which specifies a foreign key relationship with the {4} table.  However, since the expected foreign row specified by this value does not exist, this will result in some information being left out of the decompiled output.
+                <Parameter Type="System.String" Name="tableName" />
+                <Parameter Type="System.String" Name="primaryKey" />
+                <Parameter Type="System.String" Name="columnName" />
+                <Parameter Type="System.String" Name="columnValue" />
+                <Parameter Type="System.String" Name="foreignTableName" />
+            </Instance>
+            <Instance>
+                The {0} table contains a row with primary key(s) '{1}' whose {2} and {4} columns contain the values, '{3}' and '{5}', which specify a foreign key relationship with the {6} table.  However, since the expected foreign row specified by this value does not exist, this will result in some information being left out of the decompiled output.
+                <Parameter Type="System.String" Name="tableName" />
+                <Parameter Type="System.String" Name="primaryKey" />
+                <Parameter Type="System.String" Name="columnName1" />
+                <Parameter Type="System.String" Name="columnValue1" />
+                <Parameter Type="System.String" Name="columnName2" />
+                <Parameter Type="System.String" Name="columnValue2" />
+                <Parameter Type="System.String" Name="foreignTableName" />
+            </Instance>
+        </Message>
+        <Message Id="DecompilingAsCustomTable" Number="1060">
+            <Instance>
+                The {0} table is being decompiled as a custom table.
+                <Parameter Type="System.String" Name="tableName" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalPatchCreationTable" Number="1061">
+            <Instance>
+                The {0} table is not legal in a patch creation file.  The information in this table will be left out of the decompiled output.
+                <Parameter Type="System.String" Name="tableName" />
+            </Instance>
+        </Message>
+        <Message Id="SkippingMergeModuleTable" Number="1062">
+            <Instance>
+                The {0} table can only be represented in WiX for merge modules.  The information in this table will be left out of the decompiled output.
+                <Parameter Type="System.String" Name="tableName" />
+            </Instance>
+        </Message>
+        <Message Id="SkippingPatchCreationTable" Number="1063">
+            <Instance>
+                The {0} table can only be represented in WiX for patch creation files.  The information in this table will be left out of the decompiled output.
+                <Parameter Type="System.String" Name="tableName" />
+            </Instance>
+        </Message>
+        <Message Id="UnrepresentableColumnValue" Number="1064">
+            <Instance>
+                The {0}.{1} column's value, '{2}', cannot currently be represented in the WiX schema.
+                <Parameter Type="System.String" Name="tableName" />
+                <Parameter Type="System.String" Name="columnName" />
+                <Parameter Type="System.Object" Name="value" />
+            </Instance>
+        </Message>
+        <Message Id="DeprecatedTable" Number="1065" SourceLineNumbers="no">
+            <Instance>
+                The {0} table is not supported by the WiX toolset because it has been deprecated by the Windows Installer team.  Any information in this table will be left out of the decompiled output.
+                <Parameter Type="System.String" Name="tableName" />
+            </Instance>
+        </Message>
+        <Message Id="PatchTable" Number="1066">
+            <Instance>
+                The {0} table is added to the install package by a transform from a patch package (.msp) and not authored directly into an install package (.msi). The information in this table will be left out of the decompiled output.
+                <Parameter Type="System.String" Name="tableName" />
+            </Instance>
+        </Message>
+        <Message Id="IllegalColumnValue" Number="1067">
+            <Instance>
+                The {0}.{1} column's value, '{2}', is not a recognized legal value.  This information will be left out of the decompiled output.
+                <Parameter Type="System.String" Name="tableName" />
+                <Parameter Type="System.String" Name="columnName" />
+                <Parameter Type="System.Object" Name="value" />
+            </Instance>
+        </Message>
+        <Message Id="DeprecatedLongNameAttribute" Number="1069">
+            <Instance>
+                The {0}/@{1} attribute has been deprecated.  Since WiX now has the ability to generate short file/directory names, the desired name should be specified in the {2} attribute instead.  If the name specified in the {2} attribute is a short name, then WiX will not generate a short name.  If the name specified in the {2} attribute is a long name and you want to manually specify the short name, please set the short name value in the {3} attribute.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="longNameAttributeName" />
+                <Parameter Type="System.String" Name="nameAttributeName" />
+                <Parameter Type="System.String" Name="shortNameAttributeName" />
+            </Instance>
+        </Message>
+        <Message Id="GeneratedShortFileNameConflict" Number="1070">
+            <Instance>
+                The short file name '{0}' was generated for multiple files that may be installed to the same directory.  This could be due to conflicting long file names specified by the File/@Name attribute.  If that is the case, please resolve the conflict in those attributes.  Otherwise, please manually set the File/@ShortName attribute on the conflicting row to fix the collision.  If one of the colliding files was added via a patch, that short file name should be specified manually to avoid disturbing the original short file name.
+                <Parameter Type="System.String" Name="shortFileName" />
+            </Instance>
+        </Message>
+        <Message Id="GeneratedShortFileNameConflict2" Number="1071">
+            <Instance>
+                The location of a conflicting generated short file name related to the previous warning.
+            </Instance>
+        </Message>
+        <Message Id="DangerousTableInMergeModule" Number="1072">
+            <Instance>
+                Merge modules should not contain the '{0}' table because all merge conflicts cannot avoided.  However, this warning can be suppressed if all of the consumers of the Merge Module agree to not duplicate identifiers in the '{0}' table.
+                <Parameter Type="System.String" Name="tableName" />
+            </Instance>
+        </Message>
+        <Message Id="DeprecatedLocalizationVariablePrefix" Number="1073">
+            <Instance>
+                The localization variable $(loc.{0}) uses a deprecated prefix '$'.  Please use the '!' prefix instead.  Since the prefix '$' is also used by the preprocessor, it has been deprecated to avoid namespace collisions.
+                <Parameter Type="System.String" Name="variableId" />
+            </Instance>
+        </Message>
+        <Message Id="PlaceholderValue" Number="1074">
+            <Instance>
+                The {0}/@{1} attribute's value, '{2}', is a placeholder value used in example files.  Please replace this placeholder with the appropriate value.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+            </Instance>
+        </Message>
+        <Message Id="MissingUpgradeCode" Number="1075">
+            <Instance>The Product/@UpgradeCode attribute was not found; it is strongly recommended to ensure that this product can be upgraded.</Instance>
+        </Message>
+        <Message Id="ValidationWarning" Number="1076">
+            <Instance>
+                {0}: {1}
+                <Parameter Type="System.String" Name="ice" />
+                <Parameter Type="System.String" Name="message" />
+            </Instance>
+        </Message>
+        <Message Id="PropertyValueContainsPropertyReference" Number="1077">
+            <Instance>
+                The '{0}' Property contains '[{1}]' in its value which is an illegal reference to another property.  If this value is a string literal, not a property reference, please ignore this warning.  To set a property with the value of another property, use a CustomAction with Property and Value attributes.
+                <Parameter Type="System.String" Name="propertyId" />
+                <Parameter Type="System.String" Name="otherProperty" />
+            </Instance>
+        </Message>
+        <Message Id="DeprecatedUpgradeProperty" Number="1078">
+            <Instance>Specifying a Property element as a child of an Upgrade element has been deprecated.  Please specify this Property element as a child of a different element such as Product or Fragment.</Instance>
+        </Message>
+        <Message Id="EmptyCabinet" Number="1079">
+            <Instance>
+                The cabinet '{0}' does not contain any files.  If this installation contains no files, this warning can likely be safely ignored.  Otherwise, please add files to the cabinet or remove it.
+                <Parameter Type="System.String" Name="cabinetName" />
+            </Instance>
+            <Instance>
+                The cabinet '{0}' does not contain any files.  If this patch contains no files, this warning can likely be safely ignored.  Otherwise, try passing -p to torch.exe when first building the transforms, or add a ComponentRef to your PatchFamily authoring to pull changed files into the cabinet.
+                <Parameter Type="System.String" Name="cabinetName" />
+                <Parameter Type="System.Boolean" Name="isPatch" />
+            </Instance>
+        </Message>
+        <Message Id="DeprecatedRegistryElement" Number="1080">
+            <Instance>The Registry element has been deprecated.  Please use one of the new elements which replaces its functionality: RegistryKey for creating registry keys, RegistryValue for writing registry values, RemoveRegistryKey for removing registry keys, and RemoveRegistryValue for removing registry values.</Instance>
+        </Message>
+        <Message Id="IllegalRegistryKeyPath" Number="1081">
+            <Instance>
+                Component '{0}' specifies an illegal registry keypath of '{1}'.  Since this entry actually represents a registry key, not a registry value, it cannot be the keypath.
+                <Parameter Type="System.String" Name="componentName" />
+                <Parameter Type="System.String" Name="registryId" />
+            </Instance>
+        </Message>
+        <Message Id="DeprecatedPatchSequenceTargetAttribute" Number="1082">
+            <Instance>
+                The {0}/@{1} attribute has been deprecated in favor of the more strongly-typed ProductCode or TargetImage attributes.  Please use the ProductCode attribute for indicating the ProductCode of a patch family directly, or the TargetImage attribute to specify the TargetImage which in turn will retrieve the ProductCode of the patch family.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+            </Instance>
+        </Message>
+        <Message Id="ProductIdAuthored" Number="1083">
+            <Instance>
+                The 'ProductID' property should not be directly authored because it will prevent the ValidateProductID standard action from performing any validation during the installation.  This property will be set by the ValidateProductID standard action or control event.
+            </Instance>
+        </Message>
+        <Message Id="ImplicitMergeModulePrimaryFeature" Number="1084" SourceLineNumbers="no">
+            <Instance>
+                The merge module '{0}' does not have an explicit primary feature parent specified.  If the source files are linked in a different order, the primary parent feature may change.  To prevent accidental changes, the primary feature parent should be set to 'yes' in one of the MergeRef/@Primary or FeatureGroupRef/@Primary locations for this component.
+                <Parameter Type="System.String" Name="componentId" />
+            </Instance>
+        </Message>
+        <Message Id="DeprecatedIgnoreModularizationElement" Number="1085">
+            <Instance>
+                The IgnoreModularization element has been deprecated.  Use the Binary/@SuppressModularization, CustomAction/@SuppressModularization, or Property/@SuppressModularization attribute instead.
+            </Instance>
+        </Message>
+        <Message Id="PropertyModularizationSuppressed" Number="1086">
+            <Instance>
+                The Property/@SuppressModularization attribute has been set to 'yes'.  Using this functionality is strongly discouraged; it should only be necessary as a workaround of last resort in rare scenarios.
+            </Instance>
+        </Message>
+        <Message Id="DeprecatedPackageCompressedAttribute" Number="1087">
+            <Instance>
+                The Package/@Compressed attribute is deprecated under the Module element because merge modules must always be compressed.
+            </Instance>
+        </Message>
+        <Message Id="DeprecatedModuleGuidAttribute" Number="1088">
+            <Instance>
+                The Module/@Guid attribute is deprecated merge modules use their package code as the modularization guid.  Use the Package/@Id attribute instead.
+            </Instance>
+        </Message>
+        <Message Id="DeprecatedQuestionMarksGuid" Number="1090">
+            <Instance>
+                The {0}/@{1} attribute's value '????????-????-????-????-????????????' has been deprecated.  Use '*' instead.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+            </Instance>
+        </Message>
+        <Message Id="PackageCodeSet" Number="1091">
+            <Instance>
+                The Package/@Id attribute has been set.  Setting this attribute will allow nonidentical .msi files to have the same package code.  This may be a problem because the package code is the primary identifier used by the installer to search for and validate the correct package for a given installation.  If a package is changed without changing the package code, the installer may not use the newer package if both are still accessible to the installer.  Please remove the Id attribute in order to automatically generate a new package code for each new .msi file.
+            </Instance>
+        </Message>
+        <Message Id="InvalidModuleOrBundleVersion" Number="1093">
+            <Instance>
+                Invalid {0}/@Version '{1}'. {0} version has a max value of "65535.65535.65535.65535" and must be all numeric.
+                <Parameter Type="System.String" Name="moduleOrBundle" />
+                <Parameter Type="System.String" Name="version" />
+            </Instance>
+        </Message>
+        <Message Id="InvalidRemoveFile" Number="1095">
+            <Instance>
+                File '{0}' was removed from component '{1}'. Removing a file from a component will not result in the file being removed by a patch. You should author a RemoveFile element in your component to remove the file from the installation if you want the file to be removed.
+                <Parameter Type="System.String" Name="file" />
+                <Parameter Type="System.String" Name="component" />
+            </Instance>
+        </Message>
+        <Message Id="PreprocessorWarning" Number="1096">
+            <Instance>
+                {0}
+                <Parameter Type="System.String" Name="message" />
+            </Instance>
+        </Message>
+        <Message Id="UpdateOfNonKeyPathFile" Number="1097" SourceLineNumbers="no">
+            <Instance>
+                File '{0}' in Component '{1}' was changed, but the KeyPath file '{2}' was not. This file will not be patched on the target system if the REINSTALLMODE does not contain 'A'. The KeyPath file should also be changed and included in your patch.
+                <Parameter Type="System.String" Name="nonKeyPathFileId" />
+                <Parameter Type="System.String" Name="componentId" />
+                <Parameter Type="System.String" Name="keyPathFileId" />
+            </Instance>
+        </Message>
+        <Message Id="UnsupportedCommandLineArgument" Number="1098" SourceLineNumbers="no">
+            <Instance>
+                '{0}' is not a valid command line argument.
+                <Parameter Type="System.String" Name="arg" />
+            </Instance>
+        </Message>
+        <Message Id="MajorUpgradePatchNotRecommended" Number="1099" SourceLineNumbers="no">
+            <Instance>
+                Changing the ProductCode in a patch is not recommended because the patch cannot be uninstalled nor can it be sequenced along with other patches for the target product. See http://msdn2.microsoft.com/library/aa367571.aspx for more information.
+            </Instance>
+        </Message>
+        <Message Id="RetainRangeMismatch" Number="1100">
+            <Instance>
+                Mismatch in RetainRangeCounts for the file '{0}' - ignoring the retain ranges.
+                <Parameter Type="System.String" Name="fileId"/>
+            </Instance>
+        </Message>
+        <Message Id="DefaultLanguageUsedForVersionedFile" Number="1101">
+            <Instance>
+                The DefaultLanguage '{0}' was used for file '{1}' which has no language. Specifying a language that is different from the actual file may result in unexpected versioning behavior during a repair or while patching. Either specify a value for DefaultLanguage or put the language in the version information resource to eliminate this warning.
+                <Parameter Type="System.String" Name="language"/>
+                <Parameter Type="System.String" Name="fileId"/>
+            </Instance>
+        </Message>
+        <Message Id="DefaultLanguageUsedForUnversionedFile" Number="1102">
+            <Instance>
+                The DefaultLanguage '{0}' was used for file '{1}' which has no language or version. For unversioned files, specifying a value for DefaultLanguage is not neccessary and it will not be used when determining file versions. Remove the DefaultLanguage attribute to eliminate this warning.
+                <Parameter Type="System.String" Name="language"/>
+                <Parameter Type="System.String" Name="fileId"/>
+            </Instance>
+        </Message>
+        <Message Id="DefaultVersionUsedForUnversionedFile" Number="1103">
+            <Instance>
+                The DefaultVersion '{0}' was used for file '{1}' which has no version. No entry for this file will be placed in the MsiFileHash table. For unversioned files, specifying a version that is different from the actual file may result in unexpected versioning behavior during a repair or while patching. Version the resource to eliminate this warning.
+                <Parameter Type="System.String" Name="version"/>
+                <Parameter Type="System.String" Name="fileId"/>
+            </Instance>
+        </Message>
+        <Message Id="InvalidHigherInstallerVersionInModule" Number="1104">
+            <Instance>
+                Merge module '{0}' has an installer version of {1} which is greater than the product's installer version of {2}. Merging a module with a higher installer version than the product it is being merged into can result in invalid values in the resulting msi. You must set the Package/@InstallerVersion attribute to {1} or greater to merge this merge module into your product.
+                <Parameter Type="System.String" Name="moduleId" />
+                <Parameter Type="System.Int32" Name="moduleInstallerVersion" />
+                <Parameter Type="System.Int32" Name="productInstallerVersion" />
+            </Instance>
+        </Message>
+        <Message Id="ValidationFailedDueToSystemPolicy" Number="1105" SourceLineNumbers="no">
+            <Instance>
+                Validation could not run due to system policy. To eliminate this warning, run the process as admin or suppress ICE validation.
+            </Instance>
+        </Message>
+        <Message Id="ColumnsIncompatibleWithInstallerVersion" Number="1106">
+            <Instance>
+                Table '{0}' uses columns that require a version of Windows Installer greater than specified in your package ('{1}').
+                <Parameter Type="System.String" Name="tableName" />
+                <Parameter Type="System.Int32" Name="productInstallerVersion" />
+            </Instance>
+        </Message>
+        <Message Id="TableIncompatibleWithInstallerVersion" Number="1107">
+            <Instance>
+                Using table '{0}' requires a version of Windows Installer greater than specified in your package ('{1}').
+                <Parameter Type="System.String" Name="tableName" />
+                <Parameter Type="System.Int32" Name="productInstallerVersion" />
+            </Instance>
+        </Message>
+        <Message Id="DeprecatedCommandLineSwitch" Number="1108" SourceLineNumbers="no">
+            <Instance>
+                The command line switch '{0}' is deprecated.
+                <Parameter Type="System.String" Name="oldSwitch" />
+            </Instance>
+            <Instance>
+                The command line switch '{0}' is deprecated. Please use '{1}' instead.
+                <Parameter Type="System.String" Name="oldSwitch" />
+                <Parameter Type="System.String" Name="newSwitch" />
+            </Instance>
+        </Message>
+        <Message Id="UnexpectedEntrySection" Number="1109">
+            <Instance>
+                Found mismatched entry point &lt;{0}&gt;. Expected &lt;{1}&gt; for specified output package type {2}.
+                <Parameter Type="System.String" Name="sectionType" />
+                <Parameter Type="System.String" Name="expectedType" />
+                <Parameter Type="System.String" Name="outputExtension" />
+            </Instance>
+        </Message>
+        <Message Id="NewComponentAddedToExistingFeature" Number="1110">
+            <Instance>
+                Component '{0}' was added to feature '{1}' in the transform '{2}'. If you cannot guarantee that this feature will always be installed, you should consider adding new components to new top-level features to prevent prompts for source when installing this patch.
+                <Parameter Type="System.String" Name="component" />
+                <Parameter Type="System.String" Name="feature" />
+                <Parameter Type="System.String" Name="transformPath" />
+            </Instance>
+        </Message>
+        <Message Id="DeprecatedAttributeValue" Number="1111">
+            <Instance>
+                The value &quot;{0}&quot; for the {1}/@{2} attribute has been deprecated.  Please use &quot;{3}&quot; instead.
+                <Parameter Type="System.String" Name="attributeValue" />
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="newAttributeValue" />
+            </Instance>
+        </Message>
+        <Message Id="InsufficientPermissionHarvestTypeLib" Number="1112" SourceLineNumbers="no">
+            <Instance>
+                Not enough permissions to harvest type library. On Windows Vista, you must either run Heat elevated, or install Windows Vista SP1 (or higher).
+            </Instance>
+        </Message>
+        <Message Id="UnclearShortcut" Number="1113">
+            <Instance>
+                Because it is an advertised shortcut, the target of shortcut '{0}' will be the keypath of component '{2}' rather than parent file '{1}'. To eliminate this warning, you can (1) make the Shortcut element a child of the File element that is the keypath of component '{2}', (2) make file '{1}' the keypath of component '{2}', or (3) remove the @Advertise attribute so the shortcut is a non-advertised shortcut.
+                <Parameter Type="System.String" Name="shortcutId" />
+                <Parameter Type="System.String" Name="fileId" />
+                <Parameter Type="System.String" Name="componentId" />
+            </Instance>
+        </Message>
+        <Message Id="TooManyProgIds" Number="1114">
+            <Instance>
+                Class '{0}' tried to use ProgId '{1}' which has already been associated with class '{2}'. This information will be left out of the decompiled output.
+                <Parameter Type="System.String" Name="clsId" />
+                <Parameter Type="System.String" Name="progId" />
+                <Parameter Type="System.String" Name="otherClsId" />
+            </Instance>
+        </Message>
+        <Message Id="BadColumnDataIgnored" Number="1115">
+            <Instance>
+                The value '{0}' in table '{1}', column '{2}' is invalid according to the column's validation information. The decompiled output includes a best-effort representation of this value.
+                <Parameter Type="System.String" Name="value" />
+                <Parameter Type="System.String" Name="tableName" />
+                <Parameter Type="System.String" Name="columnName" />
+            </Instance>
+        </Message>
+        <Message Id="NullMsiAssemblyNameValue" Number="1116">
+            <Instance>
+                The assembly in component '{0}' has a null or empty {1} assembly name value.
+                <Parameter Type="System.String" Name="componentName" />
+                <Parameter Type="System.String" Name="name" />
+            </Instance>
+        </Message>
+        <Message Id="InvalidAttributeCombination" Number="1117">
+            <Instance>
+                It is invalid to combine attributes {0} and {1}.  The decompiled output will set attribute {2} to {3}.
+                <Parameter Type="System.String" Name="attrib1" />
+                <Parameter Type="System.String" Name="attrib2" />
+                <Parameter Type="System.String" Name="name" />
+                <Parameter Type="System.String" Name="value" />
+            </Instance>
+        </Message>
+        <Message Id="VariableDeclarationCollision" Number="1118">
+            <Instance>
+                The variable '{0}' with value '{1}' was previously declared with value '{2}'.
+                <Parameter Type="System.String" Name="variableName" />
+                <Parameter Type="System.String" Name="variableValue" />
+                <Parameter Type="System.String" Name="variableCollidingValue" />
+            </Instance>
+        </Message>
+        <Message Id="DuplicatePrimaryKey" Number="1119">
+            <Instance>
+                The primary key '{0}' is duplicated in table '{1}' and will be ignored. Please remove one of the entries or rename a part of the primary key to avoid the collision.
+                <Parameter Type="System.String" Name="primaryKey" />
+                <Parameter Type="System.String" Name="tableName" />
+            </Instance>
+        </Message>
+        <Message Id="RequiresMsi200for64bitPackage" Number="1121">
+            <Instance>
+                Package/@InstallerVersion must be 200 or greater for a 64-bit package. The value will be changed to 200. Please specify a value of 200 or greater in order to eliminate this warning.
+            </Instance>
+        </Message>
+        <Message Id="ExternalCabsAreNotSigned" Number="1122" SourceLineNumbers="no">
+            <Instance>
+                The installer database '{0}' has external cabs, but at least one of them is not signed. Please ensure that all external cabs are signed, if you mean to sign them. If you don't mean to sign them, there is no need to run the insignia tool as part of your build.
+                <Parameter Type="System.String" Name="databaseFile" />
+            </Instance>
+        </Message>
+        <Message Id="FailedToDeleteTempDir" Number="1123" SourceLineNumbers="no">
+            <Instance>
+                Failed to delete temporary directory: {0}
+                <Parameter Type="System.String" Name="directory" />
+            </Instance>
+        </Message>
+        <Message Id="StandardDirectoryConflictInMergeModule" Number="1124">
+            <Instance>
+                The Directory '{0}' starts with the same Id as the standard folder in Windows Installer '{1}'. A directory Id that begins with the same Id as a standard folder that is in an MSM may encounter a conflict when merging the MSM into an MSI. This may result in the contents of this merge module being installed to an unexpected location. To eliminate this warning, change your directory Id to not start with the same Id as any standard folders.
+                <Parameter Type="System.String" Name="directory" />
+                <Parameter Type="System.String" Name="standardDirectory" />
+            </Instance>
+        </Message>
+        <Message Id="PreprocessorUnknownPragma" Number="1125">
+            <Instance>
+                The pragma '{0}' is unknown. Please ensure you have referenced the extension that defines this pragma.
+                <Parameter Type="System.String" Name="pragmaName" />
+            </Instance>
+        </Message>
+        <Message Id="DeprecatedComponentGroupId" Number="1126">
+            <Instance>
+                The {0}/@Id attribute contains invalid characters for an identifier. Being able to use invalid identifier characters for a {0} identifier has been deprecated.
+                <Parameter Type="System.String" Name="elementName" />
+            </Instance>
+        </Message>
+        <Message Id="UxPayloadsOnlySupportEmbedding" Number="1127">
+            <Instance>
+                A UX Payload ('{0}') was marked for something other than embedded packaging, possibly because it included a @DownloadUrl attribute. At present, UX Payloads must be embedded in the Bundle, so the requested packaging is being ignored.
+                <Parameter Type="System.String" Name="sourceFile" />
+            </Instance>
+        </Message>
+        <Message Id="DiscardedRollbackBoundary" Number="1129">
+            <Instance>
+                The RollbackBoundary '{0}' was discarded because it was not followed by a package. Without a package the rollback boundary doesn't do anything. Verify that the RollbackBoundary element is not followed by another RollbackBoundary and that the element is not at the end of the chain.
+                <Parameter Type="System.String" Name="rollbackBoundaryId" />
+            </Instance>
+        </Message>
+        <Message Id="DeprecatedElement" Number="1130">
+            <Instance>
+                The {0} element has been deprecated.
+                <Parameter Type="System.String" Name="elementName" />
+            </Instance>
+            <Instance>
+                The {0} element has been deprecated.  Please use the {1} element instead.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="newElementName" />
+            </Instance>
+            <Instance>
+                The {0} element has been deprecated.  Please use the {1} or {2} element instead.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="newElementName1" />
+                <Parameter Type="System.String" Name="newElementName2" />
+            </Instance>
+        </Message>
+        <Message Id="CannotUpdateCabCache" Number="1131">
+            <Instance>
+                Cannot update the timestamp of cached cabinet: '{0}'. If the timestamp is not updated, the build may rebuild more than is necessary. To fix the issue, ensure that the cabinet file is writable, error: {1}
+                <Parameter Type="System.String" Name="cabinetPath" />
+                <Parameter Type="System.String" Name="detail" />
+            </Instance>
+        </Message>
+        <Message Id="DownloadUrlNotSupportedForEmbeddedPayloads" Number="1132">
+            <Instance>
+                The Payload '{0}' is embedded but included a @DownloadUrl attribute. Embedded Payloads cannot be downloaded so the download URL is being ignored.
+                <Parameter Type="System.String" Name="payloadId" />
+            </Instance>
+        </Message>
+        <Message Id="DiscouragedAllUsersValue" Number="1133">
+            <Instance>
+                Bundles require a package to be either per-machine or per-user. The MSI '{0}' ALLUSERS Property is set to '2' which may change from per-user to per-machine at install time. The Bundle will assume the package is per-{1} and will not work correctly if that changes. If possible, remove the Property with Id='ALLUSERS' and use Package/@InstallScope attribute instead.
+                <Parameter Type="System.String" Name="path" />
+                <Parameter Type="System.String" Name="machineOrUser" />
+            </Instance>
+        </Message>
+        <Message Id="ImplicitlyPerUser" Number="1134">
+            <Instance>
+                The MSI '{0}' does not explicitly indicate that it is a per-user package even though the ALLUSERS Property is blank. This suggests a per-user package so the Bundle will assume the package is per-user. If possible, use the Package/@InstallScope attribute to be explicit instead.
+                <Parameter Type="System.String" Name="path" />
+            </Instance>
+        </Message>
+        <Message Id="PerUserButForcingPerMachine" Number="1135">
+            <Instance>
+                The MSI '{0}' is a per-user package being forced to per-machine. Verify that the MsiPackage/@ForcePerMachine attribute is expected and that the per-user package works correctly when forced to install per-machine.
+                <Parameter Type="System.String" Name="path" />
+            </Instance>
+        </Message>
+        <Message Id="AttributeShouldContain" Number="1136">
+            <Instance>
+                The {0}/@{1} attribute value '{2}' should contain '{3}' when the {0}/@{4} attribute is set to '{5}'.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="attributeValue" />
+                <Parameter Type="System.String" Name="expectedContains" />
+                <Parameter Type="System.String" Name="otherAttributeName" />
+                <Parameter Type="System.String" Name="otherAttributeValue" />
+            </Instance>
+        </Message>
+        <Message Id="DuplicateComponentGuidsMustHaveMutuallyExclusiveConditions" Number="1137">
+            <Instance>
+                Component/@Id='{0}' has a @Guid value '{1}' that duplicates another component in this package. This is not officially supported by Windows Installer but works as long as all components have mutually-exclusive conditions. It is recommended to give each component its own unique GUID.
+                <Parameter Type="System.String" Name="componentId" />
+                <Parameter Type="System.String" Name="guid" />
+            </Instance>
+        </Message>
+        <Message Id="DeprecatedRegistryKeyActionAttribute" Number="1138">
+            <Instance>
+                The RegistryKey/@Action attribute has been deprecated.  In most cases, you can simply omit @Action.  If you need to force Windows Installer to create an empty key or recursively delete the key, use the ForceCreateOnInstall or ForceDeleteOnUninstall attributes instead.
+            </Instance>
+        </Message>
+        <Message Id="NotABinaryWixlib" Number="1139" SourceLineNumbers="no">
+          <Instance>
+            '{0}' is not a binary Wixlib and has no embedded files.
+            <Parameter Type="System.String" Name="wixlib" />
+          </Instance>
+        </Message>
+        <Message Id="NoPerMachineDependencies" Number="1140">
+            <Instance>
+                Bundle dependencies will not be registered on per-machine package '{0}' for a per-user bundle. Either make sure that all packages are installed per-machine, or author any per-machine dependencies as permanent packages.
+                <Parameter Type="System.String" Name="packageId" />
+            </Instance>
+        </Message>
+        <Message Id="DownloadUrlNotSupportedForAttachedContainers" Number="1141">
+            <Instance>
+                The Container '{0}' is attached but included a @DownloadUrl attribute. Attached Containers cannot be downloaded so the download URL is being ignored.
+                <Parameter Type="System.String" Name="containerId" />
+            </Instance>
+        </Message>
+        <Message Id="ReservedAttribute" Number="1142">
+            <Instance>
+                The {0}/@{1} attribute is reserved for future use and has no effect in this version of the WiX toolset.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+            </Instance>
+        </Message>
+        <Message Id="RequiresMsi500forArmPackage" Number="1143">
+            <Instance>
+                Package/@InstallerVersion must be 500 or greater for an Arm package. The value will be changed to 500. Please specify a value of 500 or greater in order to eliminate this warning.
+            </Instance>
+        </Message>
+        <Message Id="RemotePayloadsMustNotAlsoBeCompressed" Number="1144">
+            <Instance>
+                The {0}/@Compressed attribute must have value 'no' when a RemotePayload child element is present. RemotePayload indicates that a package will always be downloaded and cannot be compressed into a bundle. To eliminate this warning, explicitly set the {0}/@Compressed attribute to 'no'.
+                <Parameter Type="System.String" Name="elementName" />
+            </Instance>
+        </Message>
+        <Message Id="AllChangesIncludedInPatch" Number="1145">
+            <Instance>
+                All changes between the baseline and upgraded packages will be included in the patch except for any change to the ProductCode. The 'All' element is supported primarily for testing purposes and negates the benefits of patch families.
+            </Instance>
+        </Message>
+        <Message Id="RelatedAttributeConditionallyIgnored" Number="1146">
+            <Instance>
+                Ignoring attribute {0} because attribute {1} is set to {2}.
+                <Parameter Type="System.String" Name="recessiveAttribute" />
+                <Parameter Type="System.String" Name="dominantAttribute" />
+                <Parameter Type="System.String" Name="dominantValue" />
+            </Instance>
+        </Message>
+        <Message Id="BackslashTerminateInlineDirectorySyntax" Number="1147">
+            <Instance>
+                Backslash terminate the {0}/@{1} attribute's inline directory value '{2}'. A backslash ensures a directory name will not be mistaken for a directory reference.
+                <Parameter Type="System.String" Name="elementName" />
+                <Parameter Type="System.String" Name="attributeName" />
+                <Parameter Type="System.String" Name="value" />
+            </Instance>
+        </Message>
+        <Message Id="VersionTruncated" Number="1148">
+            <Instance>
+                Product version {0} in package '{1}' is not valid per the MSI SDK and cannot be represented in a bundle. It has been truncated to {2}.
+                <Parameter Type="System.String" Name="originalVersion" />
+                <Parameter Type="System.String" Name="package" />
+                <Parameter Type="System.String" Name="truncatedVersion" />
+            </Instance>
+        </Message>
+        <Message Id="ServiceConfigFamilyNotSupported" Number="1149">
+            <Instance>
+                {0} functionality is documented in the Windows Installer SDK to "not [work] as expected." Consider replacing {0} with the WixUtilExtension ServiceConfig element.
+                <Parameter Type="System.String" Name="elementName" />
+            </Instance>
+        </Message>
+    </Class>
+
+    <Class Name="WixVerboses" ContainerName="WixVerboseEventArgs" BaseContainerName="MessageEventArgs" Level="Verbose">
+        <Message Id="ImportBinaryStream" Number="9000" SourceLineNumbers="no">
+            <Instance>
+                Importing binary stream from '{0}'.
+                <Parameter Type="System.String" Name="streamSource" />
+            </Instance>
+        </Message>
+        <Message Id="ImportIconStream" Number="9001" SourceLineNumbers="no">
+            <Instance>
+                Importing icon stream from '{0}'.
+                <Parameter Type="System.String" Name="streamSource" />
+            </Instance>
+        </Message>
+        <Message Id="CopyFile" Number="9002" SourceLineNumbers="no">
+            <Instance>
+                Copying file '{0}' to '{1}'.
+                <Parameter Type="System.String" Name="sourceFile" />
+                <Parameter Type="System.String" Name="destinationFile" />
+            </Instance>
+        </Message>
+        <Message Id="MoveFile" Number="9003" SourceLineNumbers="no">
+            <Instance>
+                Moving file '{0}' to '{1}'.
+                <Parameter Type="System.String" Name="sourceFile" />
+                <Parameter Type="System.String" Name="destinationFile" />
+            </Instance>
+        </Message>
+        <Message Id="CreateDirectory" Number="9004" SourceLineNumbers="no">
+            <Instance>
+                The directory '{0}' does not exist, creating it now.
+                <Parameter Type="System.String" Name="directory" />
+            </Instance>
+        </Message>
+        <Message Id="RemoveDestinationFile" Number="9005" SourceLineNumbers="no">
+            <Instance>
+                The destination file '{0}' already exists, attempting to remove it.
+                <Parameter Type="System.String" Name="destinationFile" />
+            </Instance>
+        </Message>
+        <Message Id="CabFile" Number="9006" SourceLineNumbers="no">
+            <Instance>
+                Cabbing file {0} from '{1}'.
+                <Parameter Type="System.String" Name="fileId" />
+                <Parameter Type="System.String" Name="filePath" />
+            </Instance>
+        </Message>
+        <Message Id="UpdatingFileInformation" Number="9007" SourceLineNumbers="no">
+            <Instance>Updating file information.</Instance>
+        </Message>
+        <Message Id="GeneratingDatabase" Number="9008" SourceLineNumbers="no">
+            <Instance>Generating database.</Instance>
+        </Message>
+        <Message Id="MergingModules" Number="9009" SourceLineNumbers="no">
+            <Instance>Merging modules.</Instance>
+        </Message>
+        <Message Id="CreatingCabinetFiles" Number="9010" SourceLineNumbers="no">
+            <Instance>Creating cabinet files.</Instance>
+        </Message>
+        <Message Id="ImportingStreams" Number="9011" SourceLineNumbers="no">
+            <Instance>Importing streams.</Instance>
+        </Message>
+        <Message Id="LayingOutMedia" Number="9012" SourceLineNumbers="no">
+            <Instance>Laying out media.</Instance>
+        </Message>
+        <Message Id="DecompilingTable" Number="9013" SourceLineNumbers="no">
+            <Instance>
+                Decompiling the {0} table.
+                <Parameter Type="System.String" Name="tableName" />
+            </Instance>
+        </Message>
+        <Message Id="ValidationInfo" Number="9014" SourceLineNumbers="no">
+            <Instance>
+                {0}: {1}
+                <Parameter Type="System.String" Name="ice" />
+                <Parameter Type="System.String" Name="message" />
+            </Instance>
+        </Message>
+        <Message Id="CreateCabinet" Number="9015" SourceLineNumbers="no">
+            <Instance>
+                Creating cabinet '{0}'.
+                <Parameter Type="System.String" Name="cabinet" />
+            </Instance>
+        </Message>
+        <Message Id="ValidatingDatabase" Number="9016" SourceLineNumbers="no">
+            <Instance>Validating database.</Instance>
+        </Message>
+        <Message Id="OpeningMergeModule" Number="9017" SourceLineNumbers="no">
+            <Instance>
+                Opening merge module '{0}' with language '{1}'.
+                <Parameter Type="System.String" Name="modulePath" />
+                <Parameter Type="System.Int16" Name="language" />
+            </Instance>
+        </Message>
+        <Message Id="MergingMergeModule" Number="9018" SourceLineNumbers="no">
+            <Instance>
+                Merging merge module '{0}'.
+                <Parameter Type="System.String" Name="modulePath" />
+            </Instance>
+        </Message>
+        <Message Id="ConnectingMergeModule" Number="9019" SourceLineNumbers="no">
+            <Instance>
+                Connecting merge module '{0}' to feature '{1}'.
+                <Parameter Type="System.String" Name="modulePath" />
+                <Parameter Type="System.String" Name="feature" />
+            </Instance>
+        </Message>
+        <Message Id="ResequencingMergeModuleFiles" Number="9020" SourceLineNumbers="no">
+            <Instance>Resequencing files from all merge modules.</Instance>
+        </Message>
+        <Message Id="BinderTempDirLocatedAt" Number="9021" SourceLineNumbers="no">
+            <Instance>
+                Binder temporary directory located at '{0}'.
+                <Parameter Type="System.String" Name="directory" />
+            </Instance>
+        </Message>
+        <Message Id="ValidatorTempDirLocatedAt" Number="9022" SourceLineNumbers="no">
+            <Instance>
+                Validator temporary directory located at '{0}'.
+                <Parameter Type="System.String" Name="directory" />
+            </Instance>
+        </Message>
+        <Message Id="GeneratingBundle" Number="9023" SourceLineNumbers="no">
+            <Instance>
+                Generating Burn bundle '{0}' from stub '{1}'.
+                <Parameter Type="System.String" Name="bundleFile" />
+                <Parameter Type="System.String" Name="stubFile" />
+            </Instance>
+        </Message>
+        <Message Id="ResolvingManifest" Number="9024" SourceLineNumbers="no">
+            <Instance>
+                Generating resolved manifest '{0}'.
+                <Parameter Type="System.String" Name="manifestFile" />
+            </Instance>
+        </Message>
+        <Message Id="LoadingPayload" Number="9025" SourceLineNumbers="no">
+            <Instance>
+                Loading payload '{0}' into container.
+                <Parameter Type="System.String" Name="payload" />
+            </Instance>
+        </Message>
+        <Message Id="BundleGuid" Number="9026" SourceLineNumbers="no">
+            <Instance>
+                Assigning bundle GUID '{0}'.
+                <Parameter Type="System.String" Name="bundleGuid" />
+            </Instance>
+        </Message>
+        <Message Id="CopyingExternalPayload" Number="9027" SourceLineNumbers="no">
+            <Instance>
+                Copying external payload from '{0}' to '{1}'.
+                <Parameter Type="System.String" Name="payload" />
+                <Parameter Type="System.String" Name="outputDirectory" />
+            </Instance>
+        </Message>
+        <Message Id="EmbeddingContainer" Number="9028" SourceLineNumbers="no">
+            <Instance>
+                Embedding container '{0}' ({1} bytes) with '{2}' compression.
+                <Parameter Type="System.String" Name="container" />
+                <Parameter Type="System.Int64" Name="size" />
+                <Parameter Type="System.String" Name="compression" />
+            </Instance>
+        </Message>
+        <Message Id="SwitchingToPerUserPackage" Number="9029">
+            <Instance>
+                Bundle switching from per-machine to per-user due to addition of per-user package '{0}'.
+                <Parameter Type="System.String" Name="path" />
+            </Instance>
+        </Message>
+        <Message Id="SetCabbingThreadCount" Number="9030" SourceLineNumbers="no">
+            <Instance>
+                There will be '{0}' threads used to produce CAB files.
+                <Parameter Type="System.String" Name="threads" />
+            </Instance>
+        </Message>
+        <Message Id="ValidationSerialized" Number="9031" SourceLineNumbers="no">
+            <Instance>
+                Multiple packages cannot reliably be validated simultaneously. This validation will resume when the other package being validated has completed.
+            </Instance>
+        </Message>
+        <Message Id="ReusingCabCache" Number="9032">
+            <Instance>
+                Reusing cabinet '{0}' from cabinet cache path: '{1}'.
+                <Parameter Type="System.String" Name="cabinetName" />
+                <Parameter Type="System.String" Name="source" />
+            </Instance>
+        </Message>
+        <Message Id="CabinetsSplitInParallel" Number="9033" SourceLineNumbers="no">
+            <Instance>
+                Multiple Cabinets with Large Files are splitting simultaneously. This current cabinet is waiting on a shared resource and splitting will resume when the other splitting has completed.
+            </Instance>
+        </Message>
+        <Message Id="ValidatedDatabase" Number="9034" SourceLineNumbers="no">
+            <Instance>
+                Validation complete: {0:N0}ms elapsed.
+                <Parameter Type="System.Int64" Name="size" />
+            </Instance>
+        </Message>
+    </Class>
+</Messages>
diff --git a/src/WixToolset.Core/Decompiler.cs b/src/WixToolset.Core/Decompiler.cs
new file mode 100644
index 00000000..249b5788
--- /dev/null
+++ b/src/WixToolset.Core/Decompiler.cs
@@ -0,0 +1,9357 @@
+// 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
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Collections.Specialized;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Globalization;
+    using System.IO;
+    using System.Text;
+    using System.Text.RegularExpressions;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+    using WixToolset.Extensibility;
+    using WixToolset.Msi;
+    using WixToolset.Core.Native;
+    using Wix = WixToolset.Data.Serialize;
+
+    /// <summary>
+    /// Decompiles an msi database into WiX source.
+    /// </summary>
+    public class Decompiler
+    {
+        private static readonly Regex NullSplitter = new Regex(@"\[~]");
+
+        private int codepage;
+        private bool compressed;
+        private bool shortNames;
+        private DecompilerCore core;
+        private string exportFilePath;
+        private List<IDecompilerExtension> extensions;
+        private Dictionary<string, IDecompilerExtension> extensionsByTableName;
+        private string modularizationGuid;
+        private OutputType outputType;
+        private Hashtable patchTargetFiles;
+        private Hashtable sequenceElements;
+        private bool showPedanticMessages;
+        private WixActionRowCollection standardActions;
+        private bool suppressCustomTables;
+        private bool suppressDroppingEmptyTables;
+        private bool suppressRelativeActionSequencing;
+        private bool suppressUI;
+        private TableDefinitionCollection tableDefinitions;
+        // private TempFileCollection tempFiles;
+        private bool treatProductAsModule;
+
+        /// <summary>
+        /// Creates a new decompiler object with a default set of table definitions.
+        /// </summary>
+        public Decompiler()
+        {
+            this.standardActions = WindowsInstallerStandard.GetStandardActions();
+
+            this.extensions = new List<IDecompilerExtension>();
+            this.extensionsByTableName = new Dictionary<string,IDecompilerExtension>();
+            this.patchTargetFiles = new Hashtable();
+            this.sequenceElements = new Hashtable();
+            this.tableDefinitions = new TableDefinitionCollection();
+            this.exportFilePath = "SourceDir";
+        }
+
+        /// <summary>
+        /// Gets or sets the base source file path.
+        /// </summary>
+        /// <value>Base source file path.</value>
+        public string ExportFilePath
+        {
+            get { return this.exportFilePath; }
+            set { this.exportFilePath = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the option to show pedantic messages.
+        /// </summary>
+        /// <value>The option to show pedantic messages.</value>
+        public bool ShowPedanticMessages
+        {
+            get { return this.showPedanticMessages; }
+            set { this.showPedanticMessages = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the option to suppress custom tables.
+        /// </summary>
+        /// <value>The option to suppress dropping empty tables.</value>
+        public bool SuppressCustomTables
+        {
+            get { return this.suppressCustomTables; }
+            set { this.suppressCustomTables = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the option to suppress dropping empty tables.
+        /// </summary>
+        /// <value>The option to suppress dropping empty tables.</value>
+        public bool SuppressDroppingEmptyTables
+        {
+            get { return this.suppressDroppingEmptyTables; }
+            set { this.suppressDroppingEmptyTables = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the option to suppress decompiling with relative action sequencing (uses sequence numbers).
+        /// </summary>
+        /// <value>The option to suppress decompiling with relative action sequencing (uses sequence numbers).</value>
+        public bool SuppressRelativeActionSequencing
+        {
+            get { return this.suppressRelativeActionSequencing; }
+            set { this.suppressRelativeActionSequencing = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the option to suppress decompiling UI-related tables.
+        /// </summary>
+        /// <value>The option to suppress decompiling UI-related tables.</value>
+        public bool SuppressUI
+        {
+            get { return this.suppressUI; }
+            set { this.suppressUI = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the temporary path for the Decompiler.  If left null, the decompiler
+        /// will use %TEMP% environment variable.
+        /// </summary>
+        /// <value>Path to temp files.</value>
+        public string TempFilesLocation
+        {
+            get
+            {
+                // return null == this.tempFiles ? String.Empty : this.tempFiles.BasePath;
+                return Path.GetTempPath();
+            }
+
+            // set
+            // {
+            //     if (null == value)
+            //     {
+            //         this.tempFiles = new TempFileCollection();
+            //     }
+            //     else
+            //     {
+            //         this.tempFiles = new TempFileCollection(value);
+            //     }
+            // }
+        }
+
+        /// <summary>
+        /// Gets or sets whether the decompiler should use module logic on a product output.
+        /// </summary>
+        /// <value>The option to treat a product like a module</value>
+        public bool TreatProductAsModule
+        {
+            get { return this.treatProductAsModule; }
+            set { this.treatProductAsModule = value; }
+        }
+
+        /// <summary>
+        /// Decompile the database file.
+        /// </summary>
+        /// <param name="output">The output to decompile.</param>
+        /// <returns>The serialized WiX source code.</returns>
+        [SuppressMessage("Microsoft.Globalization", "CA1303:DoNotPassLiteralsAsLocalizedParameters", MessageId = "System.InvalidOperationException.#ctor(System.String)")]
+        public Wix.Wix Decompile(Output output)
+        {
+            if (null == output)
+            {
+                throw new ArgumentNullException("output");
+            }
+
+            this.codepage = output.Codepage;
+            this.outputType = output.Type;
+
+            // collect the table definitions from the output
+            this.tableDefinitions.Clear();
+            foreach (Table table in output.Tables)
+            {
+                this.tableDefinitions.Add(table.Definition);
+            }
+
+            // add any missing standard and wix-specific table definitions
+            foreach (TableDefinition tableDefinition in WindowsInstallerStandard.GetTableDefinitions())
+            {
+                if (!this.tableDefinitions.Contains(tableDefinition.Name))
+                {
+                    this.tableDefinitions.Add(tableDefinition);
+                }
+            }
+
+            // add any missing extension table definitions
+            foreach (IDecompilerExtension extension in this.extensions)
+            {
+                if (null != extension.TableDefinitions)
+                {
+                    foreach (TableDefinition tableDefinition in extension.TableDefinitions)
+                    {
+                        if (!this.tableDefinitions.Contains(tableDefinition.Name))
+                        {
+                            this.tableDefinitions.Add(tableDefinition);
+                        }
+                    }
+                }
+            }
+
+            // if we don't have the temporary files object yet, get one
+#if REDO_IN_NETCORE
+            if (null == this.tempFiles)
+            {
+                this.TempFilesLocation = null;
+            }
+#endif
+            Directory.CreateDirectory(this.TempFilesLocation); // ensure the base path is there
+
+            bool encounteredError = false;
+            Wix.IParentElement rootElement;
+            Wix.Wix wixElement = new Wix.Wix();
+
+            switch (this.outputType)
+            {
+                case OutputType.Module:
+                    rootElement = new Wix.Module();
+                    break;
+                case OutputType.PatchCreation:
+                    rootElement = new Wix.PatchCreation();
+                    break;
+                case OutputType.Product:
+                    rootElement = new Wix.Product();
+                    break;
+                default:
+                    throw new InvalidOperationException(WixStrings.EXP_UnknownOutputType);
+            }
+            wixElement.AddChild((Wix.ISchemaElement)rootElement);
+
+            // try to decompile the database file
+            try
+            {
+                this.core = new DecompilerCore(rootElement);
+                this.core.ShowPedanticMessages = this.showPedanticMessages;
+
+                // stop processing if an error previously occurred
+                if (this.core.EncounteredError)
+                {
+                    return null;
+                }
+
+                // initialize the decompiler and its extensions
+                foreach (IDecompilerExtension extension in this.extensions)
+                {
+                    extension.Core = this.core;
+                    extension.Initialize(output.Tables);
+                }
+                this.InitializeDecompile(output.Tables);
+
+                // stop processing if an error previously occurred
+                if (this.core.EncounteredError)
+                {
+                    return null;
+                }
+
+                // decompile the tables
+                this.DecompileTables(output);
+
+                // finalize the decompiler and its extensions
+                this.FinalizeDecompile(output.Tables);
+                foreach (IDecompilerExtension extension in this.extensions)
+                {
+                    extension.Finish(output.Tables);
+                }
+            }
+            finally
+            {
+                encounteredError = this.core.EncounteredError;
+
+                this.core = null;
+                foreach (IDecompilerExtension extension in this.extensions)
+                {
+                    extension.Core = null;
+                }
+            }
+
+            // return the root element only if decompilation completed successfully
+            return (encounteredError ? null : wixElement);
+        }
+
+        /// <summary>
+        /// Adds an extension.
+        /// </summary>
+        /// <param name="extension">The extension to add.</param>
+        public void AddExtension(IDecompilerExtension extension)
+        {
+            this.extensions.Add(extension);
+
+            if (null != extension.TableDefinitions)
+            {
+                foreach (TableDefinition tableDefinition in extension.TableDefinitions)
+                {
+                    if (!this.extensionsByTableName.ContainsKey(tableDefinition.Name))
+                    {
+                        this.extensionsByTableName.Add(tableDefinition.Name, extension);
+                    }
+                    else
+                    {
+                        Messaging.Instance.OnMessage(WixErrors.DuplicateExtensionTable(extension.GetType().ToString(), tableDefinition.Name));
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Cleans up the temp files used by the Decompiler.
+        /// </summary>
+        /// <returns>True if all files were deleted, false otherwise.</returns>
+        /// <remarks>
+        /// This should be called after every call to Decompile to ensure there
+        /// are no conflicts between each decompiled database.
+        /// </remarks>
+        public bool DeleteTempFiles()
+        {
+#if REDO_IN_NETCORE
+            if (null == this.tempFiles)
+            {
+                return true; // no work to do
+            }
+            else
+            {
+                bool deleted = Common.DeleteTempFiles(this.tempFiles.BasePath, this.core);
+
+                if (deleted)
+                {
+                    this.tempFiles = null; // temp files have been deleted, no need to remember this now
+                }
+
+                return deleted;
+            }
+#endif 
+            return true;
+        }
+
+        /// <summary>
+        /// Set the common control attributes in a control element.
+        /// </summary>
+        /// <param name="attributes">The control attributes.</param>
+        /// <param name="control">The control element.</param>
+        private static void SetControlAttributes(int attributes, Wix.Control control)
+        {
+            if (0 == (attributes & MsiInterop.MsidbControlAttributesEnabled))
+            {
+                control.Disabled = Wix.YesNoType.yes;
+            }
+
+            if (MsiInterop.MsidbControlAttributesIndirect == (attributes & MsiInterop.MsidbControlAttributesIndirect))
+            {
+                control.Indirect = Wix.YesNoType.yes;
+            }
+
+            if (MsiInterop.MsidbControlAttributesInteger == (attributes & MsiInterop.MsidbControlAttributesInteger))
+            {
+                control.Integer = Wix.YesNoType.yes;
+            }
+
+            if (MsiInterop.MsidbControlAttributesLeftScroll == (attributes & MsiInterop.MsidbControlAttributesLeftScroll))
+            {
+                control.LeftScroll = Wix.YesNoType.yes;
+            }
+
+            if (MsiInterop.MsidbControlAttributesRightAligned == (attributes & MsiInterop.MsidbControlAttributesRightAligned))
+            {
+                control.RightAligned = Wix.YesNoType.yes;
+            }
+
+            if (MsiInterop.MsidbControlAttributesRTLRO == (attributes & MsiInterop.MsidbControlAttributesRTLRO))
+            {
+                control.RightToLeft = Wix.YesNoType.yes;
+            }
+
+            if (MsiInterop.MsidbControlAttributesSunken == (attributes & MsiInterop.MsidbControlAttributesSunken))
+            {
+                control.Sunken = Wix.YesNoType.yes;
+            }
+
+            if (0 == (attributes & MsiInterop.MsidbControlAttributesVisible))
+            {
+                control.Hidden = Wix.YesNoType.yes;
+            }
+        }
+
+        /// <summary>
+        /// Creates an action element.
+        /// </summary>
+        /// <param name="actionRow">The action row from which the element should be created.</param>
+        private void CreateActionElement(WixActionRow actionRow)
+        {
+            Wix.ISchemaElement actionElement = null;
+
+            if (null != this.core.GetIndexedElement("CustomAction", actionRow.Action)) // custom action
+            {
+                Wix.Custom custom = new Wix.Custom();
+
+                custom.Action = actionRow.Action;
+
+                if (null != actionRow.Condition)
+                {
+                    custom.Content = actionRow.Condition;
+                }
+
+                switch (actionRow.Sequence)
+                {
+                    case (-4):
+                        custom.OnExit = Wix.ExitType.suspend;
+                        break;
+                    case (-3):
+                        custom.OnExit = Wix.ExitType.error;
+                        break;
+                    case (-2):
+                        custom.OnExit = Wix.ExitType.cancel;
+                        break;
+                    case (-1):
+                        custom.OnExit = Wix.ExitType.success;
+                        break;
+                    default:
+                        if (null != actionRow.Before)
+                        {
+                            custom.Before = actionRow.Before;
+                        }
+                        else if (null != actionRow.After)
+                        {
+                            custom.After = actionRow.After;
+                        }
+                        else if (0 < actionRow.Sequence)
+                        {
+                            custom.Sequence = actionRow.Sequence;
+                        }
+                        break;
+                }
+
+                actionElement = custom;
+            }
+            else if (null != this.core.GetIndexedElement("Dialog", actionRow.Action)) // dialog
+            {
+                Wix.Show show = new Wix.Show();
+
+                show.Dialog = actionRow.Action;
+
+                if (null != actionRow.Condition)
+                {
+                    show.Content = actionRow.Condition;
+                }
+
+                switch (actionRow.Sequence)
+                {
+                    case (-4):
+                        show.OnExit = Wix.ExitType.suspend;
+                        break;
+                    case (-3):
+                        show.OnExit = Wix.ExitType.error;
+                        break;
+                    case (-2):
+                        show.OnExit = Wix.ExitType.cancel;
+                        break;
+                    case (-1):
+                        show.OnExit = Wix.ExitType.success;
+                        break;
+                    default:
+                        if (null != actionRow.Before)
+                        {
+                            show.Before = actionRow.Before;
+                        }
+                        else if (null != actionRow.After)
+                        {
+                            show.After = actionRow.After;
+                        }
+                        else if (0 < actionRow.Sequence)
+                        {
+                            show.Sequence = actionRow.Sequence;
+                        }
+                        break;
+                }
+
+                actionElement = show;
+            }
+            else // possibly a standard action without suggested sequence information
+            {
+                actionElement = this.CreateStandardActionElement(actionRow);
+            }
+
+            // add the action element to the appropriate sequence element
+            if (null != actionElement)
+            {
+                string sequenceTable = actionRow.SequenceTable.ToString();
+                Wix.IParentElement sequenceElement = (Wix.IParentElement)this.sequenceElements[sequenceTable];
+
+                if (null == sequenceElement)
+                {
+                    switch (actionRow.SequenceTable)
+                    {
+                        case SequenceTable.AdminExecuteSequence:
+                            sequenceElement = new Wix.AdminExecuteSequence();
+                            break;
+                        case SequenceTable.AdminUISequence:
+                            sequenceElement = new Wix.AdminUISequence();
+                            break;
+                        case SequenceTable.AdvtExecuteSequence:
+                            sequenceElement = new Wix.AdvertiseExecuteSequence();
+                            break;
+                        case SequenceTable.InstallExecuteSequence:
+                            sequenceElement = new Wix.InstallExecuteSequence();
+                            break;
+                        case SequenceTable.InstallUISequence:
+                            sequenceElement = new Wix.InstallUISequence();
+                            break;
+                        default:
+                            throw new InvalidOperationException(WixStrings.EXP_UnknowSequenceTable);
+                    }
+
+                    this.core.RootElement.AddChild((Wix.ISchemaElement)sequenceElement);
+                    this.sequenceElements.Add(sequenceTable, sequenceElement);
+                }
+
+                try
+                {
+                    sequenceElement.AddChild(actionElement);
+                }
+                catch (System.ArgumentException) // action/dialog is not valid for this sequence
+                {
+                    this.core.OnMessage(WixWarnings.IllegalActionInSequence(actionRow.SourceLineNumbers, actionRow.SequenceTable.ToString(), actionRow.Action));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Creates a standard action element.
+        /// </summary>
+        /// <param name="actionRow">The action row from which the element should be created.</param>
+        /// <returns>The created element.</returns>
+        private Wix.ISchemaElement CreateStandardActionElement(WixActionRow actionRow)
+        {
+            Wix.ActionSequenceType actionElement = null;
+
+            switch (actionRow.Action)
+            {
+                case "AllocateRegistrySpace":
+                    actionElement = new Wix.AllocateRegistrySpace();
+                    break;
+                case "AppSearch":
+                    WixActionRow appSearchActionRow = this.standardActions[actionRow.SequenceTable, actionRow.Action];
+
+                    if (null != actionRow.Before || null != actionRow.After || (null != appSearchActionRow && actionRow.Sequence != appSearchActionRow.Sequence))
+                    {
+                        Wix.AppSearch appSearch = new Wix.AppSearch();
+
+                        if (null != actionRow.Condition)
+                        {
+                            appSearch.Content = actionRow.Condition;
+                        }
+
+                        if (null != actionRow.Before)
+                        {
+                            appSearch.Before = actionRow.Before;
+                        }
+                        else if (null != actionRow.After)
+                        {
+                            appSearch.After = actionRow.After;
+                        }
+                        else if (0 < actionRow.Sequence)
+                        {
+                            appSearch.Sequence = actionRow.Sequence;
+                        }
+
+                        return appSearch;
+                    }
+                    break;
+                case "BindImage":
+                    actionElement = new Wix.BindImage();
+                    break;
+                case "CCPSearch":
+                    Wix.CCPSearch ccpSearch = new Wix.CCPSearch();
+                    Decompiler.SequenceRelativeAction(actionRow, ccpSearch);
+                    return ccpSearch;
+                case "CostFinalize":
+                    actionElement = new Wix.CostFinalize();
+                    break;
+                case "CostInitialize":
+                    actionElement = new Wix.CostInitialize();
+                    break;
+                case "CreateFolders":
+                    actionElement = new Wix.CreateFolders();
+                    break;
+                case "CreateShortcuts":
+                    actionElement = new Wix.CreateShortcuts();
+                    break;
+                case "DeleteServices":
+                    actionElement = new Wix.DeleteServices();
+                    break;
+                case "DisableRollback":
+                    Wix.DisableRollback disableRollback = new Wix.DisableRollback();
+                    Decompiler.SequenceRelativeAction(actionRow, disableRollback);
+                    return disableRollback;
+                case "DuplicateFiles":
+                    actionElement = new Wix.DuplicateFiles();
+                    break;
+                case "ExecuteAction":
+                    actionElement = new Wix.ExecuteAction();
+                    break;
+                case "FileCost":
+                    actionElement = new Wix.FileCost();
+                    break;
+                case "FindRelatedProducts":
+                    Wix.FindRelatedProducts findRelatedProducts = new Wix.FindRelatedProducts();
+                    Decompiler.SequenceRelativeAction(actionRow, findRelatedProducts);
+                    return findRelatedProducts;
+                case "ForceReboot":
+                    Wix.ForceReboot forceReboot = new Wix.ForceReboot();
+                    Decompiler.SequenceRelativeAction(actionRow, forceReboot);
+                    return forceReboot;
+                case "InstallAdminPackage":
+                    actionElement = new Wix.InstallAdminPackage();
+                    break;
+                case "InstallExecute":
+                    Wix.InstallExecute installExecute = new Wix.InstallExecute();
+                    Decompiler.SequenceRelativeAction(actionRow, installExecute);
+                    return installExecute;
+                case "InstallExecuteAgain":
+                    Wix.InstallExecuteAgain installExecuteAgain = new Wix.InstallExecuteAgain();
+                    Decompiler.SequenceRelativeAction(actionRow, installExecuteAgain);
+                    return installExecuteAgain;
+                case "InstallFiles":
+                    actionElement = new Wix.InstallFiles();
+                    break;
+                case "InstallFinalize":
+                    actionElement = new Wix.InstallFinalize();
+                    break;
+                case "InstallInitialize":
+                    actionElement = new Wix.InstallInitialize();
+                    break;
+                case "InstallODBC":
+                    actionElement = new Wix.InstallODBC();
+                    break;
+                case "InstallServices":
+                    actionElement = new Wix.InstallServices();
+                    break;
+                case "InstallValidate":
+                    actionElement = new Wix.InstallValidate();
+                    break;
+                case "IsolateComponents":
+                    actionElement = new Wix.IsolateComponents();
+                    break;
+                case "LaunchConditions":
+                    Wix.LaunchConditions launchConditions = new Wix.LaunchConditions();
+                    Decompiler.SequenceRelativeAction(actionRow, launchConditions);
+                    return launchConditions;
+                case "MigrateFeatureStates":
+                    actionElement = new Wix.MigrateFeatureStates();
+                    break;
+                case "MoveFiles":
+                    actionElement = new Wix.MoveFiles();
+                    break;
+                case "MsiPublishAssemblies":
+                    actionElement = new Wix.MsiPublishAssemblies();
+                    break;
+                case "MsiUnpublishAssemblies":
+                    actionElement = new Wix.MsiUnpublishAssemblies();
+                    break;
+                case "PatchFiles":
+                    actionElement = new Wix.PatchFiles();
+                    break;
+                case "ProcessComponents":
+                    actionElement = new Wix.ProcessComponents();
+                    break;
+                case "PublishComponents":
+                    actionElement = new Wix.PublishComponents();
+                    break;
+                case "PublishFeatures":
+                    actionElement = new Wix.PublishFeatures();
+                    break;
+                case "PublishProduct":
+                    actionElement = new Wix.PublishProduct();
+                    break;
+                case "RegisterClassInfo":
+                    actionElement = new Wix.RegisterClassInfo();
+                    break;
+                case "RegisterComPlus":
+                    actionElement = new Wix.RegisterComPlus();
+                    break;
+                case "RegisterExtensionInfo":
+                    actionElement = new Wix.RegisterExtensionInfo();
+                    break;
+                case "RegisterFonts":
+                    actionElement = new Wix.RegisterFonts();
+                    break;
+                case "RegisterMIMEInfo":
+                    actionElement = new Wix.RegisterMIMEInfo();
+                    break;
+                case "RegisterProduct":
+                    actionElement = new Wix.RegisterProduct();
+                    break;
+                case "RegisterProgIdInfo":
+                    actionElement = new Wix.RegisterProgIdInfo();
+                    break;
+                case "RegisterTypeLibraries":
+                    actionElement = new Wix.RegisterTypeLibraries();
+                    break;
+                case "RegisterUser":
+                    actionElement = new Wix.RegisterUser();
+                    break;
+                case "RemoveDuplicateFiles":
+                    actionElement = new Wix.RemoveDuplicateFiles();
+                    break;
+                case "RemoveEnvironmentStrings":
+                    actionElement = new Wix.RemoveEnvironmentStrings();
+                    break;
+                case "RemoveExistingProducts":
+                    Wix.RemoveExistingProducts removeExistingProducts = new Wix.RemoveExistingProducts();
+                    Decompiler.SequenceRelativeAction(actionRow, removeExistingProducts);
+                    return removeExistingProducts;
+                case "RemoveFiles":
+                    actionElement = new Wix.RemoveFiles();
+                    break;
+                case "RemoveFolders":
+                    actionElement = new Wix.RemoveFolders();
+                    break;
+                case "RemoveIniValues":
+                    actionElement = new Wix.RemoveIniValues();
+                    break;
+                case "RemoveODBC":
+                    actionElement = new Wix.RemoveODBC();
+                    break;
+                case "RemoveRegistryValues":
+                    actionElement = new Wix.RemoveRegistryValues();
+                    break;
+                case "RemoveShortcuts":
+                    actionElement = new Wix.RemoveShortcuts();
+                    break;
+                case "ResolveSource":
+                    Wix.ResolveSource resolveSource = new Wix.ResolveSource();
+                    Decompiler.SequenceRelativeAction(actionRow, resolveSource);
+                    return resolveSource;
+                case "RMCCPSearch":
+                    Wix.RMCCPSearch rmccpSearch = new Wix.RMCCPSearch();
+                    Decompiler.SequenceRelativeAction(actionRow, rmccpSearch);
+                    return rmccpSearch;
+                case "ScheduleReboot":
+                    Wix.ScheduleReboot scheduleReboot = new Wix.ScheduleReboot();
+                    Decompiler.SequenceRelativeAction(actionRow, scheduleReboot);
+                    return scheduleReboot;
+                case "SelfRegModules":
+                    actionElement = new Wix.SelfRegModules();
+                    break;
+                case "SelfUnregModules":
+                    actionElement = new Wix.SelfUnregModules();
+                    break;
+                case "SetODBCFolders":
+                    actionElement = new Wix.SetODBCFolders();
+                    break;
+                case "StartServices":
+                    actionElement = new Wix.StartServices();
+                    break;
+                case "StopServices":
+                    actionElement = new Wix.StopServices();
+                    break;
+                case "UnpublishComponents":
+                    actionElement = new Wix.UnpublishComponents();
+                    break;
+                case "UnpublishFeatures":
+                    actionElement = new Wix.UnpublishFeatures();
+                    break;
+                case "UnregisterClassInfo":
+                    actionElement = new Wix.UnregisterClassInfo();
+                    break;
+                case "UnregisterComPlus":
+                    actionElement = new Wix.UnregisterComPlus();
+                    break;
+                case "UnregisterExtensionInfo":
+                    actionElement = new Wix.UnregisterExtensionInfo();
+                    break;
+                case "UnregisterFonts":
+                    actionElement = new Wix.UnregisterFonts();
+                    break;
+                case "UnregisterMIMEInfo":
+                    actionElement = new Wix.UnregisterMIMEInfo();
+                    break;
+                case "UnregisterProgIdInfo":
+                    actionElement = new Wix.UnregisterProgIdInfo();
+                    break;
+                case "UnregisterTypeLibraries":
+                    actionElement = new Wix.UnregisterTypeLibraries();
+                    break;
+                case "ValidateProductID":
+                    actionElement = new Wix.ValidateProductID();
+                    break;
+                case "WriteEnvironmentStrings":
+                    actionElement = new Wix.WriteEnvironmentStrings();
+                    break;
+                case "WriteIniValues":
+                    actionElement = new Wix.WriteIniValues();
+                    break;
+                case "WriteRegistryValues":
+                    actionElement = new Wix.WriteRegistryValues();
+                    break;
+                default:
+                    this.core.OnMessage(WixWarnings.UnknownAction(actionRow.SourceLineNumbers, actionRow.SequenceTable.ToString(), actionRow.Action));
+                    return null;
+            }
+
+            if (actionElement != null)
+            {
+                this.SequenceStandardAction(actionRow, actionElement);
+            }
+
+            return actionElement;
+        }
+
+        /// <summary>
+        /// Applies the condition and sequence to a standard action element based on the action row data.
+        /// </summary>
+        /// <param name="actionRow">Action row data from the database.</param>
+        /// <param name="actionElement">Element to be sequenced.</param>
+        private void SequenceStandardAction(WixActionRow actionRow, Wix.ActionSequenceType actionElement)
+        {
+            if (null != actionRow.Condition)
+            {
+                actionElement.Content = actionRow.Condition;
+            }
+
+            if ((null != actionRow.Before || null != actionRow.After) && 0 == actionRow.Sequence)
+            {
+                this.core.OnMessage(WixWarnings.DecompiledStandardActionRelativelyScheduledInModule(actionRow.SourceLineNumbers, actionRow.SequenceTable.ToString(), actionRow.Action));
+            }
+            else if (0 < actionRow.Sequence)
+            {
+                actionElement.Sequence = actionRow.Sequence;
+            }
+        }
+
+        /// <summary>
+        /// Applies the condition and relative sequence to an action element based on the action row data.
+        /// </summary>
+        /// <param name="actionRow">Action row data from the database.</param>
+        /// <param name="actionElement">Element to be sequenced.</param>
+        private static void SequenceRelativeAction(WixActionRow actionRow, Wix.ActionModuleSequenceType actionElement)
+        {
+            if (null != actionRow.Condition)
+            {
+                actionElement.Content = actionRow.Condition;
+            }
+
+            if (null != actionRow.Before)
+            {
+                actionElement.Before = actionRow.Before;
+            }
+            else if (null != actionRow.After)
+            {
+                actionElement.After = actionRow.After;
+            }
+            else if (0 < actionRow.Sequence)
+            {
+                actionElement.Sequence = actionRow.Sequence;
+            }
+        }
+
+        /// <summary>
+        /// Ensure that a particular property exists in the decompiled output.
+        /// </summary>
+        /// <param name="id">The identifier of the property.</param>
+        /// <returns>The property element.</returns>
+        private Wix.Property EnsureProperty(string id)
+        {
+            Wix.Property property = (Wix.Property)this.core.GetIndexedElement("Property", id);
+
+            if (null == property)
+            {
+                property = new Wix.Property();
+                property.Id = id;
+
+                // create a dummy row for indexing
+                Row row = new Row(null, this.tableDefinitions["Property"]);
+                row[0] = id;
+
+                this.core.RootElement.AddChild(property);
+                this.core.IndexElement(row, property);
+            }
+
+            return property;
+        }
+
+        /// <summary>
+        /// Finalize decompilation.
+        /// </summary>
+        /// <param name="tables">The collection of all tables.</param>
+        private void FinalizeDecompile(TableIndexedCollection tables)
+        {
+            if (OutputType.PatchCreation == this.outputType)
+            {
+                this.FinalizeFamilyFileRangesTable(tables);
+            }
+            else
+            {
+                this.FinalizeCheckBoxTable(tables);
+                this.FinalizeComponentTable(tables);
+                this.FinalizeDialogTable(tables);
+                this.FinalizeDuplicateMoveFileTables(tables);
+                this.FinalizeFeatureComponentsTable(tables);
+                this.FinalizeFileTable(tables);
+                this.FinalizeMIMETable(tables);
+                this.FinalizeMsiLockPermissionsExTable(tables);
+                this.FinalizeLockPermissionsTable(tables);
+                this.FinalizeProgIdTable(tables);
+                this.FinalizePropertyTable(tables);
+                this.FinalizeRemoveFileTable(tables);
+                this.FinalizeSearchTables(tables);
+                this.FinalizeUpgradeTable(tables);
+                this.FinalizeSequenceTables(tables);
+                this.FinalizeVerbTable(tables);
+            }
+        }
+
+        /// <summary>
+        /// Finalize the CheckBox table.
+        /// </summary>
+        /// <param name="tables">The collection of all tables.</param>
+        /// <remarks>
+        /// Enumerates through all the Control rows, looking for controls of type "CheckBox" with
+        /// a value in the Property column.  This is then possibly matched up with a CheckBox row
+        /// to retrieve a CheckBoxValue.  There is no foreign key from the Control to CheckBox table.
+        /// </remarks>
+        private void FinalizeCheckBoxTable(TableIndexedCollection tables)
+        {
+            // if the user has requested to suppress the UI elements, we have nothing to do
+            if (this.suppressUI)
+            {
+                return;
+            }
+
+            Table checkBoxTable = tables["CheckBox"];
+            Table controlTable = tables["Control"];
+
+            Hashtable checkBoxes = new Hashtable();
+            Hashtable checkBoxProperties = new Hashtable();
+
+            // index the CheckBox table
+            if (null != checkBoxTable)
+            {
+                foreach (Row row in checkBoxTable.Rows)
+                {
+                    checkBoxes.Add(row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), row);
+                    checkBoxProperties.Add(row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), false);
+                }
+            }
+
+            // enumerate through the Control table, adding CheckBox values where appropriate
+            if (null != controlTable)
+            {
+                foreach (Row row in controlTable.Rows)
+                {
+                    Wix.Control control = (Wix.Control)this.core.GetIndexedElement(row);
+
+                    if ("CheckBox" == Convert.ToString(row[2]) && null != row[8])
+                    {
+                        Row checkBoxRow = (Row)checkBoxes[row[8]];
+
+                        if (null == checkBoxRow)
+                        {
+                            this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, "Control", row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Property", Convert.ToString(row[8]), "CheckBox"));
+                        }
+                        else
+                        {
+                            // if we've seen this property already, create a reference to it
+                            if (Convert.ToBoolean(checkBoxProperties[row[8]]))
+                            {
+                                control.CheckBoxPropertyRef = Convert.ToString(row[8]);
+                            }
+                            else
+                            {
+                                control.Property = Convert.ToString(row[8]);
+                                checkBoxProperties[row[8]] = true;
+                            }
+
+                            if (null != checkBoxRow[1])
+                            {
+                                control.CheckBoxValue = Convert.ToString(checkBoxRow[1]);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Finalize the Component table.
+        /// </summary>
+        /// <param name="tables">The collection of all tables.</param>
+        /// <remarks>
+        /// Set the keypaths for each component.
+        /// </remarks>
+        private void FinalizeComponentTable(TableIndexedCollection tables)
+        {
+            Table componentTable = tables["Component"];
+            Table fileTable = tables["File"];
+            Table odbcDataSourceTable = tables["ODBCDataSource"];
+            Table registryTable = tables["Registry"];
+
+            // set the component keypaths
+            if (null != componentTable)
+            {
+                foreach (Row row in componentTable.Rows)
+                {
+                    int attributes = Convert.ToInt32(row[3]);
+
+                    if (null == row[5])
+                    {
+                        Wix.Component component = (Wix.Component)this.core.GetIndexedElement("Component", Convert.ToString(row[0]));
+
+                        component.KeyPath = Wix.YesNoType.yes;
+                    }
+                    else if (MsiInterop.MsidbComponentAttributesRegistryKeyPath == (attributes & MsiInterop.MsidbComponentAttributesRegistryKeyPath))
+                    {
+                        object registryObject = this.core.GetIndexedElement("Registry", Convert.ToString(row[5]));
+
+                        if (null != registryObject)
+                        {
+                            Wix.RegistryValue registryValue = registryObject as Wix.RegistryValue;
+
+                            if (null != registryValue)
+                            {
+                                registryValue.KeyPath = Wix.YesNoType.yes;
+                            }
+                            else
+                            {
+                                this.core.OnMessage(WixWarnings.IllegalRegistryKeyPath(row.SourceLineNumbers, "Component", Convert.ToString(row[5])));
+                            }
+                        }
+                        else
+                        {
+                            this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, "Component", row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "KeyPath", Convert.ToString(row[5]), "Registry"));
+                        }
+                    }
+                    else if (MsiInterop.MsidbComponentAttributesODBCDataSource == (attributes & MsiInterop.MsidbComponentAttributesODBCDataSource))
+                    {
+                        Wix.ODBCDataSource odbcDataSource = (Wix.ODBCDataSource)this.core.GetIndexedElement("ODBCDataSource", Convert.ToString(row[5]));
+
+                        if (null != odbcDataSource)
+                        {
+                            odbcDataSource.KeyPath = Wix.YesNoType.yes;
+                        }
+                        else
+                        {
+                            this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, "Component", row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "KeyPath", Convert.ToString(row[5]), "ODBCDataSource"));
+                        }
+                    }
+                    else
+                    {
+                        Wix.File file = (Wix.File)this.core.GetIndexedElement("File", Convert.ToString(row[5]));
+
+                        if (null != file)
+                        {
+                            file.KeyPath = Wix.YesNoType.yes;
+                        }
+                        else
+                        {
+                            this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, "Component", row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "KeyPath", Convert.ToString(row[5]), "File"));
+                        }
+                    }
+                }
+            }
+
+            // add the File children elements
+            if (null != fileTable)
+            {
+                foreach (FileRow fileRow in fileTable.Rows)
+                {
+                    Wix.Component component = (Wix.Component)this.core.GetIndexedElement("Component", fileRow.Component);
+                    Wix.File file = (Wix.File)this.core.GetIndexedElement(fileRow);
+
+                    if (null != component)
+                    {
+                        component.AddChild(file);
+                    }
+                    else
+                    {
+                        this.core.OnMessage(WixWarnings.ExpectedForeignRow(fileRow.SourceLineNumbers, "File", fileRow.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", fileRow.Component, "Component"));
+                    }
+                }
+            }
+
+            // add the ODBCDataSource children elements
+            if (null != odbcDataSourceTable)
+            {
+                foreach (Row row in odbcDataSourceTable.Rows)
+                {
+                    Wix.Component component = (Wix.Component)this.core.GetIndexedElement("Component", Convert.ToString(row[1]));
+                    Wix.ODBCDataSource odbcDataSource = (Wix.ODBCDataSource)this.core.GetIndexedElement(row);
+
+                    if (null != component)
+                    {
+                        component.AddChild(odbcDataSource);
+                    }
+                    else
+                    {
+                        this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, "ODBCDataSource", row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", Convert.ToString(row[1]), "Component"));
+                    }
+                }
+            }
+
+            // add the Registry children elements
+            if (null != registryTable)
+            {
+                foreach (Row row in registryTable.Rows)
+                {
+                    Wix.Component component = (Wix.Component)this.core.GetIndexedElement("Component", Convert.ToString(row[5]));
+                    Wix.ISchemaElement registryElement = (Wix.ISchemaElement)this.core.GetIndexedElement(row);
+
+                    if (null != component)
+                    {
+                        component.AddChild(registryElement);
+                    }
+                    else
+                    {
+                        this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, "Registry", row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", Convert.ToString(row[5]), "Component"));
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Finalize the Dialog table.
+        /// </summary>
+        /// <param name="tables">The collection of all tables.</param>
+        /// <remarks>
+        /// Sets the first, default, and cancel control for each dialog and adds all child control
+        /// elements to the dialog.
+        /// </remarks>
+        private void FinalizeDialogTable(TableIndexedCollection tables)
+        {
+            // if the user has requested to suppress the UI elements, we have nothing to do
+            if (this.suppressUI)
+            {
+                return;
+            }
+
+            Table controlTable = tables["Control"];
+            Table dialogTable = tables["Dialog"];
+
+            Hashtable addedControls = new Hashtable();
+            Hashtable controlRows = new Hashtable();
+
+            // index the rows in the control rows (because we need the Control_Next value)
+            if (null != controlTable)
+            {
+                foreach (Row row in controlTable.Rows)
+                {
+                    controlRows.Add(row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), row);
+                }
+            }
+
+            if (null != dialogTable)
+            {
+                foreach (Row row in dialogTable.Rows)
+                {
+                    Wix.Dialog dialog = (Wix.Dialog)this.core.GetIndexedElement(row);
+                    string dialogId = Convert.ToString(row[0]);
+
+                    Wix.Control control = (Wix.Control)this.core.GetIndexedElement("Control", dialogId, Convert.ToString(row[7]));
+                    if (null == control)
+                    {
+                        this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, "Dialog", row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Dialog", dialogId, "Control_First", Convert.ToString(row[7]), "Control"));
+                    }
+
+                    // add tabbable controls
+                    while (null != control)
+                    {
+                        Row controlRow = (Row)controlRows[String.Concat(dialogId, DecompilerConstants.PrimaryKeyDelimiter, control.Id)];
+
+                        control.TabSkip = Wix.YesNoType.no;
+                        dialog.AddChild(control);
+                        addedControls.Add(control, null);
+
+                        if (null != controlRow[10])
+                        {
+                            control = (Wix.Control)this.core.GetIndexedElement("Control", dialogId, Convert.ToString(controlRow[10]));
+                            if (null != control)
+                            {
+                                // looped back to the first control in the dialog
+                                if (addedControls.Contains(control))
+                                {
+                                    control = null;
+                                }
+                            }
+                            else
+                            {
+                                this.core.OnMessage(WixWarnings.ExpectedForeignRow(controlRow.SourceLineNumbers, "Control", controlRow.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Dialog_", dialogId, "Control_Next", Convert.ToString(controlRow[10]), "Control"));
+                            }
+                        }
+                        else
+                        {
+                            control = null;
+                        }
+                    }
+
+                    // set default control
+                    if (null != row[8])
+                    {
+                        Wix.Control defaultControl = (Wix.Control)this.core.GetIndexedElement("Control", dialogId, Convert.ToString(row[8]));
+
+                        if (null != defaultControl)
+                        {
+                            defaultControl.Default = Wix.YesNoType.yes;
+                        }
+                        else
+                        {
+                            this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, "Dialog", row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Dialog", dialogId, "Control_Default", Convert.ToString(row[8]), "Control"));
+                        }
+                    }
+
+                    // set cancel control
+                    if (null != row[9])
+                    {
+                        Wix.Control cancelControl = (Wix.Control)this.core.GetIndexedElement("Control", dialogId, Convert.ToString(row[9]));
+
+                        if (null != cancelControl)
+                        {
+                            cancelControl.Cancel = Wix.YesNoType.yes;
+                        }
+                        else
+                        {
+                            this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, "Dialog", row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Dialog", dialogId, "Control_Cancel", Convert.ToString(row[9]), "Control"));
+                        }
+                    }
+                }
+            }
+
+            // add the non-tabbable controls to the dialog
+            if (null != controlTable)
+            {
+                foreach (Row row in controlTable.Rows)
+                {
+                    Wix.Control control = (Wix.Control)this.core.GetIndexedElement(row);
+                    Wix.Dialog dialog = (Wix.Dialog)this.core.GetIndexedElement("Dialog", Convert.ToString(row[0]));
+
+                    if (null == dialog)
+                    {
+                        this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, "Control", row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Dialog_", Convert.ToString(row[0]), "Dialog"));
+                        continue;
+                    }
+
+                    if (!addedControls.Contains(control))
+                    {
+                        control.TabSkip = Wix.YesNoType.yes;
+                        dialog.AddChild(control);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Finalize the DuplicateFile and MoveFile tables.
+        /// </summary>
+        /// <param name="tables">The collection of all tables.</param>
+        /// <remarks>
+        /// Sets the source/destination property/directory for each DuplicateFile or
+        /// MoveFile row.
+        /// </remarks>
+        private void FinalizeDuplicateMoveFileTables(TableIndexedCollection tables)
+        {
+            Table duplicateFileTable = tables["DuplicateFile"];
+            Table moveFileTable = tables["MoveFile"];
+
+            if (null != duplicateFileTable)
+            {
+                foreach (Row row in duplicateFileTable.Rows)
+                {
+                    Wix.CopyFile copyFile = (Wix.CopyFile)this.core.GetIndexedElement(row);
+
+                    if (null != row[4])
+                    {
+                        if (null != this.core.GetIndexedElement("Directory", Convert.ToString(row[4])))
+                        {
+                            copyFile.DestinationDirectory = Convert.ToString(row[4]);
+                        }
+                        else
+                        {
+                            copyFile.DestinationProperty = Convert.ToString(row[4]);
+                        }
+                    }
+                }
+            }
+
+            if (null != moveFileTable)
+            {
+                foreach (Row row in moveFileTable.Rows)
+                {
+                    Wix.CopyFile copyFile = (Wix.CopyFile)this.core.GetIndexedElement(row);
+
+                    if (null != row[4])
+                    {
+                        if (null != this.core.GetIndexedElement("Directory", Convert.ToString(row[4])))
+                        {
+                            copyFile.SourceDirectory = Convert.ToString(row[4]);
+                        }
+                        else
+                        {
+                            copyFile.SourceProperty = Convert.ToString(row[4]);
+                        }
+                    }
+
+                    if (null != this.core.GetIndexedElement("Directory", Convert.ToString(row[5])))
+                    {
+                        copyFile.DestinationDirectory = Convert.ToString(row[5]);
+                    }
+                    else
+                    {
+                        copyFile.DestinationProperty = Convert.ToString(row[5]);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Finalize the FamilyFileRanges table.
+        /// </summary>
+        /// <param name="tables">The collection of all tables.</param>
+        private void FinalizeFamilyFileRangesTable(TableIndexedCollection tables)
+        {
+            Table externalFilesTable = tables["ExternalFiles"];
+            Table familyFileRangesTable = tables["FamilyFileRanges"];
+            Table targetFiles_OptionalDataTable = tables["TargetFiles_OptionalData"];
+
+            Hashtable usedProtectRanges = new Hashtable();
+
+            if (null != familyFileRangesTable)
+            {
+                foreach (Row row in familyFileRangesTable.Rows)
+                {
+                    Wix.ProtectRange protectRange = new Wix.ProtectRange();
+
+                    if (null != row[2] && null != row[3])
+                    {
+                        string[] retainOffsets = (Convert.ToString(row[2])).Split(',');
+                        string[] retainLengths = (Convert.ToString(row[3])).Split(',');
+
+                        if (retainOffsets.Length == retainLengths.Length)
+                        {
+                            for (int i = 0; i < retainOffsets.Length; i++)
+                            {
+                                if (retainOffsets[i].StartsWith("0x", StringComparison.Ordinal))
+                                {
+                                    protectRange.Offset = Convert.ToInt32(retainOffsets[i].Substring(2), 16);
+                                }
+                                else
+                                {
+                                    protectRange.Offset = Convert.ToInt32(retainOffsets[i], CultureInfo.InvariantCulture);
+                                }
+
+                                if (retainLengths[i].StartsWith("0x", StringComparison.Ordinal))
+                                {
+                                    protectRange.Length = Convert.ToInt32(retainLengths[i].Substring(2), 16);
+                                }
+                                else
+                                {
+                                    protectRange.Length = Convert.ToInt32(retainLengths[i], CultureInfo.InvariantCulture);
+                                }
+                            }
+                        }
+                        else
+                        {
+                            // TODO: warn
+                        }
+                    }
+                    else if (null != row[2] || null != row[3])
+                    {
+                        // TODO: warn about mismatch between columns
+                    }
+
+                    this.core.IndexElement(row, protectRange);
+                }
+            }
+
+            if (null != externalFilesTable)
+            {
+                foreach (Row row in externalFilesTable.Rows)
+                {
+                    Wix.ExternalFile externalFile = (Wix.ExternalFile)this.core.GetIndexedElement(row);
+
+                    Wix.ProtectRange protectRange = (Wix.ProtectRange)this.core.GetIndexedElement("FamilyFileRanges", Convert.ToString(row[0]), Convert.ToString(row[1]));
+                    if (null != protectRange)
+                    {
+                        externalFile.AddChild(protectRange);
+                        usedProtectRanges[protectRange] = null;
+                    }
+                }
+            }
+
+            if (null != targetFiles_OptionalDataTable)
+            {
+                Table targetImagesTable = tables["TargetImages"];
+                Table upgradedImagesTable = tables["UpgradedImages"];
+
+                Hashtable targetImageRows = new Hashtable();
+                Hashtable upgradedImagesRows = new Hashtable();
+
+                // index the TargetImages table
+                if (null != targetImagesTable)
+                {
+                    foreach (Row row in targetImagesTable.Rows)
+                    {
+                        targetImageRows.Add(row[0], row);
+                    }
+                }
+
+                // index the UpgradedImages table
+                if (null != upgradedImagesTable)
+                {
+                    foreach (Row row in upgradedImagesTable.Rows)
+                    {
+                        upgradedImagesRows.Add(row[0], row);
+                    }
+                }
+
+                foreach (Row row in targetFiles_OptionalDataTable.Rows)
+                {
+                    Wix.TargetFile targetFile = (Wix.TargetFile)this.patchTargetFiles[row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter)];
+
+                    Row targetImageRow = (Row)targetImageRows[row[0]];
+                    if (null == targetImageRow)
+                    {
+                        this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, targetFiles_OptionalDataTable.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Target", Convert.ToString(row[0]), "TargetImages"));
+                        continue;
+                    }
+
+                    Row upgradedImagesRow = (Row)upgradedImagesRows[targetImageRow[3]];
+                    if (null == upgradedImagesRow)
+                    {
+                        this.core.OnMessage(WixWarnings.ExpectedForeignRow(targetImageRow.SourceLineNumbers, targetImageRow.Table.Name, targetImageRow.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Upgraded", Convert.ToString(row[3]), "UpgradedImages"));
+                        continue;
+                    }
+
+                    Wix.ProtectRange protectRange = (Wix.ProtectRange)this.core.GetIndexedElement("FamilyFileRanges", Convert.ToString(upgradedImagesRow[4]), Convert.ToString(row[1]));
+                    if (null != protectRange)
+                    {
+                        targetFile.AddChild(protectRange);
+                        usedProtectRanges[protectRange] = null;
+                    }
+                }
+            }
+
+            if (null != familyFileRangesTable)
+            {
+                foreach (Row row in familyFileRangesTable.Rows)
+                {
+                    Wix.ProtectRange protectRange = (Wix.ProtectRange)this.core.GetIndexedElement(row);
+
+                    if (!usedProtectRanges.Contains(protectRange))
+                    {
+                        Wix.ProtectFile protectFile = new Wix.ProtectFile();
+
+                        protectFile.File = Convert.ToString(row[1]);
+
+                        protectFile.AddChild(protectRange);
+
+                        Wix.Family family = (Wix.Family)this.core.GetIndexedElement("ImageFamilies", Convert.ToString(row[0]));
+                        if (null != family)
+                        {
+                            family.AddChild(protectFile);
+                        }
+                        else
+                        {
+                            this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, familyFileRangesTable.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Family", Convert.ToString(row[0]), "ImageFamilies"));
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Finalize the FeatureComponents table.
+        /// </summary>
+        /// <param name="tables">The collection of all tables.</param>
+        /// <remarks>
+        /// Since tables specifying references to the FeatureComponents table have references to
+        /// the Feature and Component table separately, but not the FeatureComponents table specifically,
+        /// the FeatureComponents table and primary features must be decompiled during finalization.
+        /// </remarks>
+        private void FinalizeFeatureComponentsTable(TableIndexedCollection tables)
+        {
+            Table classTable = tables["Class"];
+            Table extensionTable = tables["Extension"];
+            Table msiAssemblyTable = tables["MsiAssembly"];
+            Table publishComponentTable = tables["PublishComponent"];
+            Table shortcutTable = tables["Shortcut"];
+            Table typeLibTable = tables["TypeLib"];
+
+            if (null != classTable)
+            {
+                foreach (Row row in classTable.Rows)
+                {
+                    this.SetPrimaryFeature(row, 11, 2);
+                }
+            }
+
+            if (null != extensionTable)
+            {
+                foreach (Row row in extensionTable.Rows)
+                {
+                    this.SetPrimaryFeature(row, 4, 1);
+                }
+            }
+
+            if (null != msiAssemblyTable)
+            {
+                foreach (Row row in msiAssemblyTable.Rows)
+                {
+                    this.SetPrimaryFeature(row, 1, 0);
+                }
+            }
+
+            if (null != publishComponentTable)
+            {
+                foreach (Row row in publishComponentTable.Rows)
+                {
+                    this.SetPrimaryFeature(row, 4, 2);
+                }
+            }
+
+            if (null != shortcutTable)
+            {
+                foreach (Row row in shortcutTable.Rows)
+                {
+                    string target = Convert.ToString(row[4]);
+
+                    if (!target.StartsWith("[", StringComparison.Ordinal) && !target.EndsWith("]", StringComparison.Ordinal))
+                    {
+                        this.SetPrimaryFeature(row, 4, 3);
+                    }
+                }
+            }
+
+            if (null != typeLibTable)
+            {
+                foreach (Row row in typeLibTable.Rows)
+                {
+                    this.SetPrimaryFeature(row, 6, 2);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Finalize the File table.
+        /// </summary>
+        /// <param name="tables">The collection of all tables.</param>
+        /// <remarks>
+        /// Sets the source, diskId, and assembly information for each file.
+        /// </remarks>
+        private void FinalizeFileTable(TableIndexedCollection tables)
+        {
+            Table fileTable = tables["File"];
+            Table mediaTable = tables["Media"];
+            Table msiAssemblyTable = tables["MsiAssembly"];
+            Table typeLibTable = tables["TypeLib"];
+
+            // index the media table by media id
+            RowDictionary<MediaRow> mediaRows;
+            if (null != mediaTable)
+            {
+                mediaRows = new RowDictionary<MediaRow>(mediaTable);
+            }
+
+            // set the disk identifiers and sources for files
+            if (null != fileTable)
+            {
+                foreach (FileRow fileRow in fileTable.Rows)
+                {
+                    Wix.File file = (Wix.File)this.core.GetIndexedElement("File", fileRow.File);
+
+                    // Don't bother processing files that are orphaned (and won't show up in the output anyway)
+                    if (null != file.ParentElement)
+                    {
+                        // set the diskid
+                        if (null != mediaTable)
+                        {
+                            foreach (MediaRow mediaRow in mediaTable.Rows)
+                            {
+                                if (fileRow.Sequence <= mediaRow.LastSequence)
+                                {
+                                    file.DiskId = Convert.ToString(mediaRow.DiskId);
+                                    break;
+                                }
+                            }
+                        }
+
+                        // set the source (done here because it requires information from the Directory table)
+                        if (OutputType.Module == this.outputType)
+                        {
+                            file.Source = String.Concat(this.exportFilePath, Path.DirectorySeparatorChar, "File", Path.DirectorySeparatorChar, file.Id, '.', this.modularizationGuid.Substring(1, 36).Replace('-', '_'));
+                        }
+                        else if (Wix.YesNoDefaultType.yes == file.Compressed || (Wix.YesNoDefaultType.no != file.Compressed && this.compressed))
+                        {
+                            file.Source = String.Concat(this.exportFilePath, Path.DirectorySeparatorChar, "File", Path.DirectorySeparatorChar, file.Id);
+                        }
+                        else // uncompressed
+                        {
+                            string fileName = (null != file.ShortName ? file.ShortName : file.Name);
+
+                            if (!this.shortNames && null != file.Name)
+                            {
+                                fileName = file.Name;
+                            }
+
+                            if (this.compressed) // uncompressed at the root of the source image
+                            {
+                                file.Source = String.Concat("SourceDir", Path.DirectorySeparatorChar, fileName);
+                            }
+                            else
+                            {
+                                string sourcePath = this.GetSourcePath(file);
+
+                                file.Source = Path.Combine(sourcePath, fileName);
+                            }
+                        }
+                    }
+                }
+            }
+
+            // set the file assemblies and manifests
+            if (null != msiAssemblyTable)
+            {
+                foreach (Row row in msiAssemblyTable.Rows)
+                {
+                    Wix.Component component = (Wix.Component)this.core.GetIndexedElement("Component", Convert.ToString(row[0]));
+
+                    if (null == component)
+                    {
+                        this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, "MsiAssembly", row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", Convert.ToString(row[0]), "Component"));
+                    }
+                    else
+                    {
+                        foreach (Wix.ISchemaElement element in component.Children)
+                        {
+                            Wix.File file = element as Wix.File;
+
+                            if (null != file && Wix.YesNoType.yes == file.KeyPath)
+                            {
+                                if (null != row[2])
+                                {
+                                    file.AssemblyManifest = Convert.ToString(row[2]);
+                                }
+
+                                if (null != row[3])
+                                {
+                                    file.AssemblyApplication = Convert.ToString(row[3]);
+                                }
+
+                                if (null == row[4] || 0 == Convert.ToInt32(row[4]))
+                                {
+                                    file.Assembly = Wix.File.AssemblyType.net;
+                                }
+                                else
+                                {
+                                    file.Assembly = Wix.File.AssemblyType.win32;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            // nest the TypeLib elements
+            if (null != typeLibTable)
+            {
+                foreach (Row row in typeLibTable.Rows)
+                {
+                    Wix.Component component = (Wix.Component)this.core.GetIndexedElement("Component", Convert.ToString(row[2]));
+                    Wix.TypeLib typeLib = (Wix.TypeLib)this.core.GetIndexedElement(row);
+
+                    foreach (Wix.ISchemaElement element in component.Children)
+                    {
+                        Wix.File file = element as Wix.File;
+
+                        if (null != file && Wix.YesNoType.yes == file.KeyPath)
+                        {
+                            file.AddChild(typeLib);
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Finalize the MIME table.
+        /// </summary>
+        /// <param name="tables">The collection of all tables.</param>
+        /// <remarks>
+        /// There is a foreign key shared between the MIME and Extension
+        /// tables so either one would be valid to be decompiled first, so
+        /// the only safe way to nest the MIME elements is to do it during finalize.
+        /// </remarks>
+        private void FinalizeMIMETable(TableIndexedCollection tables)
+        {
+            Table extensionTable = tables["Extension"];
+            Table mimeTable = tables["MIME"];
+
+            Hashtable comExtensions = new Hashtable();
+
+            if (null != extensionTable)
+            {
+                foreach (Row row in extensionTable.Rows)
+                {
+                    Wix.Extension extension = (Wix.Extension)this.core.GetIndexedElement(row);
+
+                    // index the extension
+                    if (!comExtensions.Contains(row[0]))
+                    {
+                        comExtensions.Add(row[0], new ArrayList());
+                    }
+                    ((ArrayList)comExtensions[row[0]]).Add(extension);
+
+                    // set the default MIME element for this extension
+                    if (null != row[3])
+                    {
+                        Wix.MIME mime = (Wix.MIME)this.core.GetIndexedElement("MIME", Convert.ToString(row[3]));
+
+                        if (null != mime)
+                        {
+                            mime.Default = Wix.YesNoType.yes;
+                        }
+                        else
+                        {
+                            this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, "Extension", row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "MIME_", Convert.ToString(row[3]), "MIME"));
+                        }
+                    }
+                }
+            }
+
+            if (null != mimeTable)
+            {
+                foreach (Row row in mimeTable.Rows)
+                {
+                    Wix.MIME mime = (Wix.MIME)this.core.GetIndexedElement(row);
+
+                    if (comExtensions.Contains(row[1]))
+                    {
+                        ArrayList extensionElements = (ArrayList)comExtensions[row[1]];
+
+                        foreach (Wix.Extension extension in extensionElements)
+                        {
+                            extension.AddChild(mime);
+                        }
+                    }
+                    else
+                    {
+                        this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, "MIME", row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Extension_", Convert.ToString(row[1]), "Extension"));
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Finalize the ProgId table.
+        /// </summary>
+        /// <param name="tables">The collection of all tables.</param>
+        /// <remarks>
+        /// Enumerates through all the Class rows, looking for child ProgIds (these are the
+        /// default ProgIds for a given Class).  Then go through the ProgId table and add any
+        /// remaining ProgIds for each Class.  This happens during finalize because there is
+        /// a circular dependency between the Class and ProgId tables.
+        /// </remarks>
+        private void FinalizeProgIdTable(TableIndexedCollection tables)
+        {
+            Table classTable = tables["Class"];
+            Table progIdTable = tables["ProgId"];
+            Table extensionTable = tables["Extension"];
+            Table componentTable = tables["Component"];
+
+            Hashtable addedProgIds = new Hashtable();
+            Hashtable classes = new Hashtable();
+            Hashtable components = new Hashtable();
+
+            // add the default ProgIds for each class (and index the class table)
+            if (null != classTable)
+            {
+                foreach (Row row in classTable.Rows)
+                {
+                    Wix.Class wixClass = (Wix.Class)this.core.GetIndexedElement(row);
+
+                    if (null != row[3])
+                    {
+                        Wix.ProgId progId = (Wix.ProgId)this.core.GetIndexedElement("ProgId", Convert.ToString(row[3]));
+
+                        if (null != progId)
+                        {
+                            if (addedProgIds.Contains(progId))
+                            {
+                                this.core.OnMessage(WixWarnings.TooManyProgIds(row.SourceLineNumbers, Convert.ToString(row[0]), Convert.ToString(row[3]), Convert.ToString(addedProgIds[progId])));
+                            }
+                            else
+                            {
+                                wixClass.AddChild(progId);
+                                addedProgIds.Add(progId, wixClass.Id);
+                            }
+                        }
+                        else
+                        {
+                            this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, "Class", row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "ProgId_Default", Convert.ToString(row[3]), "ProgId"));
+                        }
+                    }
+
+                    // index the Class elements for nesting of ProgId elements (which don't use the full Class primary key)
+                    if (!classes.Contains(wixClass.Id))
+                    {
+                        classes.Add(wixClass.Id, new ArrayList());
+                    }
+                    ((ArrayList)classes[wixClass.Id]).Add(wixClass);
+                }
+            }
+
+            // add the remaining non-default ProgId entries for each class
+            if (null != progIdTable)
+            {
+                foreach (Row row in progIdTable.Rows)
+                {
+                    Wix.ProgId progId = (Wix.ProgId)this.core.GetIndexedElement(row);
+
+                    if (!addedProgIds.Contains(progId) && null != row[2] && null == progId.ParentElement)
+                    {
+                        ArrayList classElements = (ArrayList)classes[row[2]];
+
+                        if (null != classElements)
+                        {
+                            foreach (Wix.Class wixClass in classElements)
+                            {
+                                wixClass.AddChild(progId);
+                                addedProgIds.Add(progId, wixClass.Id);
+                            }
+                        }
+                        else
+                        {
+                            this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, "ProgId", row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Class_", Convert.ToString(row[2]), "Class"));
+                        }
+                    }
+                }
+            }
+
+            if (null != componentTable)
+            {
+                foreach (Row row in componentTable.Rows)
+                {
+                    Wix.Component wixComponent = (Wix.Component)this.core.GetIndexedElement(row);
+
+                    // index the Class elements for nesting of ProgId elements (which don't use the full Class primary key)
+                    if (!components.Contains(wixComponent.Id))
+                    {
+                        components.Add(wixComponent.Id, new ArrayList());
+                    }
+                    ((ArrayList)components[wixComponent.Id]).Add(wixComponent);
+                }
+            }
+
+            // Check for any progIds that are not hooked up to a class and hook them up to the component specified by the extension
+            if (null != extensionTable)
+            {
+                foreach (Row row in extensionTable.Rows)
+                {
+                    // ignore the extension if it isn't associated with a progId
+                    if (null == row[2])
+                    {
+                        continue;
+                    }
+
+                    Wix.ProgId progId = (Wix.ProgId)this.core.GetIndexedElement("ProgId", Convert.ToString(row[2]));
+
+                    // Haven't added the progId yet and it doesn't have a parent progId
+                    if (!addedProgIds.Contains(progId) && null == progId.ParentElement)
+                    {
+                        ArrayList componentElements = (ArrayList)components[row[1]];
+
+                        if (null != componentElements)
+                        {
+                            foreach (Wix.Component wixComponent in componentElements)
+                            {
+                                wixComponent.AddChild(progId);
+                            }
+                        }
+                        else
+                        {
+                            this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, "Extension", row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", Convert.ToString(row[1]), "Component"));
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Finalize the Property table.
+        /// </summary>
+        /// <param name="tables">The collection of all tables.</param>
+        /// <remarks>
+        /// Removes properties that are generated from other entries.
+        /// </remarks>
+        private void FinalizePropertyTable(TableIndexedCollection tables)
+        {
+            Table propertyTable = tables["Property"];
+            Table customActionTable = tables["CustomAction"];
+
+            if (null != propertyTable && null != customActionTable)
+            {
+                foreach (Row row in customActionTable.Rows)
+                {
+                    int bits = Convert.ToInt32(row[1]);
+                    if (MsiInterop.MsidbCustomActionTypeHideTarget == (bits & MsiInterop.MsidbCustomActionTypeHideTarget) &&
+                        MsiInterop.MsidbCustomActionTypeInScript == (bits & MsiInterop.MsidbCustomActionTypeInScript))
+                    {
+                        Wix.Property property = (Wix.Property)this.core.GetIndexedElement("Property", Convert.ToString(row[0]));
+
+                        // If no other fields on the property are set we must have created it during link
+                        if (null != property && null == property.Value && Wix.YesNoType.yes != property.Secure && Wix.YesNoType.yes != property.SuppressModularization)
+                        {
+                            this.core.RootElement.RemoveChild(property);
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Finalize the RemoveFile table.
+        /// </summary>
+        /// <param name="tables">The collection of all tables.</param>
+        /// <remarks>
+        /// Sets the directory/property for each RemoveFile row.
+        /// </remarks>
+        private void FinalizeRemoveFileTable(TableIndexedCollection tables)
+        {
+            Table removeFileTable = tables["RemoveFile"];
+
+            if (null != removeFileTable)
+            {
+                foreach (Row row in removeFileTable.Rows)
+                {
+                    bool isDirectory = false;
+                    string property = Convert.ToString(row[3]);
+
+                    // determine if the property is actually authored as a directory
+                    if (null != this.core.GetIndexedElement("Directory", property))
+                    {
+                        isDirectory = true;
+                    }
+
+                    Wix.ISchemaElement element = this.core.GetIndexedElement(row);
+
+                    Wix.RemoveFile removeFile = element as Wix.RemoveFile;
+                    if (null != removeFile)
+                    {
+                        if (isDirectory)
+                        {
+                            removeFile.Directory = property;
+                        }
+                        else
+                        {
+                            removeFile.Property = property;
+                        }
+                    }
+                    else
+                    {
+                        Wix.RemoveFolder removeFolder = (Wix.RemoveFolder)element;
+
+                        if (isDirectory)
+                        {
+                            removeFolder.Directory = property;
+                        }
+                        else
+                        {
+                            removeFolder.Property = property;
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Finalize the LockPermissions table.
+        /// </summary>
+        /// <param name="tables">The collection of all tables.</param>
+        /// <remarks>
+        /// Nests the Permission elements below their parent elements.  There are no declared foreign
+        /// keys for the parents of the LockPermissions table.
+        /// </remarks>
+        private void FinalizeLockPermissionsTable(TableIndexedCollection tables)
+        {
+            Table createFolderTable = tables["CreateFolder"];
+            Table lockPermissionsTable = tables["LockPermissions"];
+
+            Hashtable createFolders = new Hashtable();
+
+            // index the CreateFolder table because the foreign key to this table from the
+            // LockPermissions table is only part of the primary key of this table
+            if (null != createFolderTable)
+            {
+                foreach (Row row in createFolderTable.Rows)
+                {
+                    Wix.CreateFolder createFolder = (Wix.CreateFolder)this.core.GetIndexedElement(row);
+                    string directoryId = Convert.ToString(row[0]);
+
+                    if (!createFolders.Contains(directoryId))
+                    {
+                        createFolders.Add(directoryId, new ArrayList());
+                    }
+                    ((ArrayList)createFolders[directoryId]).Add(createFolder);
+                }
+            }
+
+            if (null != lockPermissionsTable)
+            {
+                foreach (Row row in lockPermissionsTable.Rows)
+                {
+                    string id = Convert.ToString(row[0]);
+                    string table = Convert.ToString(row[1]);
+
+                    Wix.Permission permission = (Wix.Permission)this.core.GetIndexedElement(row);
+
+                    if ("CreateFolder" == table)
+                    {
+                        ArrayList createFolderElements = (ArrayList)createFolders[id];
+
+                        if (null != createFolderElements)
+                        {
+                            foreach (Wix.CreateFolder createFolder in createFolderElements)
+                            {
+                                createFolder.AddChild(permission);
+                            }
+                        }
+                        else
+                        {
+                            this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, "LockPermissions", row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "LockObject", id, table));
+                        }
+                    }
+                    else
+                    {
+                        Wix.IParentElement parentElement = (Wix.IParentElement)this.core.GetIndexedElement(table, id);
+
+                        if (null != parentElement)
+                        {
+                            parentElement.AddChild(permission);
+                        }
+                        else
+                        {
+                            this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, "LockPermissions", row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "LockObject", id, table));
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Finalize the MsiLockPermissionsEx table.
+        /// </summary>
+        /// <param name="tables">The collection of all tables.</param>
+        /// <remarks>
+        /// Nests the PermissionEx elements below their parent elements.  There are no declared foreign
+        /// keys for the parents of the MsiLockPermissionsEx table.
+        /// </remarks>
+        private void FinalizeMsiLockPermissionsExTable(TableIndexedCollection tables)
+        {
+            Table createFolderTable = tables["CreateFolder"];
+            Table msiLockPermissionsExTable = tables["MsiLockPermissionsEx"];
+
+            Hashtable createFolders = new Hashtable();
+
+            // index the CreateFolder table because the foreign key to this table from the
+            // MsiLockPermissionsEx table is only part of the primary key of this table
+            if (null != createFolderTable)
+            {
+                foreach (Row row in createFolderTable.Rows)
+                {
+                    Wix.CreateFolder createFolder = (Wix.CreateFolder)this.core.GetIndexedElement(row);
+                    string directoryId = Convert.ToString(row[0]);
+
+                    if (!createFolders.Contains(directoryId))
+                    {
+                        createFolders.Add(directoryId, new ArrayList());
+                    }
+                    ((ArrayList)createFolders[directoryId]).Add(createFolder);
+                }
+            }
+
+            if (null != msiLockPermissionsExTable)
+            {
+                foreach (Row row in msiLockPermissionsExTable.Rows)
+                {
+                    string id = Convert.ToString(row[1]);
+                    string table = Convert.ToString(row[2]);
+
+                    Wix.PermissionEx permissionEx = (Wix.PermissionEx)this.core.GetIndexedElement(row);
+
+                    if ("CreateFolder" == table)
+                    {
+                        ArrayList createFolderElements = (ArrayList)createFolders[id];
+
+                        if (null != createFolderElements)
+                        {
+                            foreach (Wix.CreateFolder createFolder in createFolderElements)
+                            {
+                                createFolder.AddChild(permissionEx);
+                            }
+                        }
+                        else
+                        {
+                            this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, "MsiLockPermissionsEx", row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "LockObject", id, table));
+                        }
+                    }
+                    else
+                    {
+                        Wix.IParentElement parentElement = (Wix.IParentElement)this.core.GetIndexedElement(table, id);
+
+                        if (null != parentElement)
+                        {
+                            parentElement.AddChild(permissionEx);
+                        }
+                        else
+                        {
+                            this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, "MsiLockPermissionsEx", row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "LockObject", id, table));
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Finalize the search tables.
+        /// </summary>
+        /// <param name="tables">The collection of all tables.</param>
+        /// <remarks>Does all the complex linking required for the search tables.</remarks>
+        private void FinalizeSearchTables(TableIndexedCollection tables)
+        {
+            Table appSearchTable = tables["AppSearch"];
+            Table ccpSearchTable = tables["CCPSearch"];
+            Table drLocatorTable = tables["DrLocator"];
+
+            Hashtable appSearches = new Hashtable();
+            Hashtable ccpSearches = new Hashtable();
+            Hashtable drLocators = new Hashtable();
+            Hashtable locators = new Hashtable();
+            Hashtable usedSearchElements = new Hashtable();
+            ArrayList unusedSearchElements = new ArrayList();
+
+            Wix.ComplianceCheck complianceCheck = null;
+
+            // index the AppSearch table by signatures
+            if (null != appSearchTable)
+            {
+                foreach (Row row in appSearchTable.Rows)
+                {
+                    string property = Convert.ToString(row[0]);
+                    string signature = Convert.ToString(row[1]);
+
+                    if (!appSearches.Contains(signature))
+                    {
+                        appSearches.Add(signature, new StringCollection());
+                    }
+
+                    ((StringCollection)appSearches[signature]).Add(property);
+                }
+            }
+
+            // index the CCPSearch table by signatures
+            if (null != ccpSearchTable)
+            {
+                foreach (Row row in ccpSearchTable.Rows)
+                {
+                    string signature = Convert.ToString(row[0]);
+
+                    if (!ccpSearches.Contains(signature))
+                    {
+                        ccpSearches.Add(signature, new StringCollection());
+                    }
+
+                    ((StringCollection)ccpSearches[signature]).Add(null);
+
+                    if (null == complianceCheck && !appSearches.Contains(signature))
+                    {
+                        complianceCheck = new Wix.ComplianceCheck();
+                        this.core.RootElement.AddChild(complianceCheck);
+                    }
+                }
+            }
+
+            // index the directory searches by their search elements (to get back the original row)
+            if (null != drLocatorTable)
+            {
+                foreach (Row row in drLocatorTable.Rows)
+                {
+                    drLocators.Add(this.core.GetIndexedElement(row), row);
+                }
+            }
+
+            // index the locator tables by their signatures
+            string[] locatorTableNames = new string[] { "CompLocator", "RegLocator", "IniLocator", "DrLocator", "Signature" };
+            foreach (string locatorTableName in locatorTableNames)
+            {
+                Table locatorTable = tables[locatorTableName];
+
+                if (null != locatorTable)
+                {
+                    foreach (Row row in locatorTable.Rows)
+                    {
+                        string signature = Convert.ToString(row[0]);
+
+                        if (!locators.Contains(signature))
+                        {
+                            locators.Add(signature, new ArrayList());
+                        }
+
+                        ((ArrayList)locators[signature]).Add(row);
+                    }
+                }
+            }
+
+            // move the DrLocator rows with a parent of CCP_DRIVE first to ensure they get FileSearch children (not FileSearchRef)
+            foreach (ArrayList locatorRows in locators.Values)
+            {
+                int firstDrLocator = -1;
+
+                for (int i = 0; i < locatorRows.Count; i++)
+                {
+                    Row locatorRow = (Row)locatorRows[i];
+
+                    if ("DrLocator" == locatorRow.TableDefinition.Name)
+                    {
+                        if (-1 == firstDrLocator)
+                        {
+                            firstDrLocator = i;
+                        }
+
+                        if ("CCP_DRIVE" == Convert.ToString(locatorRow[1]))
+                        {
+                            locatorRows.RemoveAt(i);
+                            locatorRows.Insert(firstDrLocator, locatorRow);
+                            break;
+                        }
+                    }
+                }
+            }
+
+            foreach (string signature in locators.Keys)
+            {
+                ArrayList locatorRows = (ArrayList)locators[signature];
+                ArrayList signatureSearchElements = new ArrayList();
+
+                foreach (Row locatorRow in locatorRows)
+                {
+                    bool used = true;
+                    Wix.ISchemaElement searchElement = this.core.GetIndexedElement(locatorRow);
+
+                    if ("Signature" == locatorRow.TableDefinition.Name && 0 < signatureSearchElements.Count)
+                    {
+                        foreach (Wix.IParentElement searchParentElement in signatureSearchElements)
+                        {
+                            if (!usedSearchElements.Contains(searchElement))
+                            {
+                                searchParentElement.AddChild(searchElement);
+                                usedSearchElements[searchElement] = null;
+                            }
+                            else
+                            {
+                                Wix.FileSearchRef fileSearchRef = new Wix.FileSearchRef();
+
+                                fileSearchRef.Id = signature;
+
+                                searchParentElement.AddChild(fileSearchRef);
+                            }
+                        }
+                    }
+                    else if ("DrLocator" == locatorRow.TableDefinition.Name && null != locatorRow[1])
+                    {
+                        string parentSignature = Convert.ToString(locatorRow[1]);
+
+                        if ("CCP_DRIVE" == parentSignature)
+                        {
+                            if (appSearches.Contains(signature))
+                            {
+                                StringCollection appSearchPropertyIds = (StringCollection)appSearches[signature];
+
+                                foreach (string propertyId in appSearchPropertyIds)
+                                {
+                                    Wix.Property property = this.EnsureProperty(propertyId);
+                                    Wix.ComplianceDrive complianceDrive = null;
+
+                                    if (ccpSearches.Contains(signature))
+                                    {
+                                        property.ComplianceCheck = Wix.YesNoType.yes;
+                                    }
+
+                                    foreach (Wix.ISchemaElement element in property.Children)
+                                    {
+                                        complianceDrive = element as Wix.ComplianceDrive;
+                                        if (null != complianceDrive)
+                                        {
+                                            break;
+                                        }
+                                    }
+
+                                    if (null == complianceDrive)
+                                    {
+                                        complianceDrive = new Wix.ComplianceDrive();
+                                        property.AddChild(complianceDrive);
+                                    }
+
+                                    if (!usedSearchElements.Contains(searchElement))
+                                    {
+                                        complianceDrive.AddChild(searchElement);
+                                        usedSearchElements[searchElement] = null;
+                                    }
+                                    else
+                                    {
+                                        Wix.DirectorySearchRef directorySearchRef = new Wix.DirectorySearchRef();
+
+                                        directorySearchRef.Id = signature;
+
+                                        if (null != locatorRow[1])
+                                        {
+                                            directorySearchRef.Parent = Convert.ToString(locatorRow[1]);
+                                        }
+
+                                        if (null != locatorRow[2])
+                                        {
+                                            directorySearchRef.Path = Convert.ToString(locatorRow[2]);
+                                        }
+
+                                        complianceDrive.AddChild(directorySearchRef);
+                                        signatureSearchElements.Add(directorySearchRef);
+                                    }
+                                }
+                            }
+                            else if (ccpSearches.Contains(signature))
+                            {
+                                Wix.ComplianceDrive complianceDrive = null;
+
+                                foreach (Wix.ISchemaElement element in complianceCheck.Children)
+                                {
+                                    complianceDrive = element as Wix.ComplianceDrive;
+                                    if (null != complianceDrive)
+                                    {
+                                        break;
+                                    }
+                                }
+
+                                if (null == complianceDrive)
+                                {
+                                    complianceDrive = new Wix.ComplianceDrive();
+                                    complianceCheck.AddChild(complianceDrive);
+                                }
+
+                                if (!usedSearchElements.Contains(searchElement))
+                                {
+                                    complianceDrive.AddChild(searchElement);
+                                    usedSearchElements[searchElement] = null;
+                                }
+                                else
+                                {
+                                    Wix.DirectorySearchRef directorySearchRef = new Wix.DirectorySearchRef();
+
+                                    directorySearchRef.Id = signature;
+
+                                    if (null != locatorRow[1])
+                                    {
+                                        directorySearchRef.Parent = Convert.ToString(locatorRow[1]);
+                                    }
+
+                                    if (null != locatorRow[2])
+                                    {
+                                        directorySearchRef.Path = Convert.ToString(locatorRow[2]);
+                                    }
+
+                                    complianceDrive.AddChild(directorySearchRef);
+                                    signatureSearchElements.Add(directorySearchRef);
+                                }
+                            }
+                        }
+                        else
+                        {
+                            bool usedDrLocator = false;
+                            ArrayList parentLocatorRows = (ArrayList)locators[parentSignature];
+
+                            if (null != parentLocatorRows)
+                            {
+                                foreach (Row parentLocatorRow in parentLocatorRows)
+                                {
+                                    if ("DrLocator" == parentLocatorRow.TableDefinition.Name)
+                                    {
+                                        Wix.IParentElement parentSearchElement = (Wix.IParentElement)this.core.GetIndexedElement(parentLocatorRow);
+
+                                        if (parentSearchElement.Children.GetEnumerator().MoveNext())
+                                        {
+                                            Row parentDrLocatorRow = (Row)drLocators[parentSearchElement];
+                                            Wix.DirectorySearchRef directorySeachRef = new Wix.DirectorySearchRef();
+
+                                            directorySeachRef.Id = parentSignature;
+
+                                            if (null != parentDrLocatorRow[1])
+                                            {
+                                                directorySeachRef.Parent = Convert.ToString(parentDrLocatorRow[1]);
+                                            }
+
+                                            if (null != parentDrLocatorRow[2])
+                                            {
+                                                directorySeachRef.Path = Convert.ToString(parentDrLocatorRow[2]);
+                                            }
+
+                                            parentSearchElement = directorySeachRef;
+                                            unusedSearchElements.Add(directorySeachRef);
+                                        }
+
+                                        if (!usedSearchElements.Contains(searchElement))
+                                        {
+                                            parentSearchElement.AddChild(searchElement);
+                                            usedSearchElements[searchElement] = null;
+                                            usedDrLocator = true;
+                                        }
+                                        else
+                                        {
+                                            Wix.DirectorySearchRef directorySearchRef = new Wix.DirectorySearchRef();
+
+                                            directorySearchRef.Id = signature;
+
+                                            directorySearchRef.Parent = parentSignature;
+
+                                            if (null != locatorRow[2])
+                                            {
+                                                directorySearchRef.Path = Convert.ToString(locatorRow[2]);
+                                            }
+
+                                            parentSearchElement.AddChild(searchElement);
+                                            usedDrLocator = true;
+                                        }
+                                    }
+                                }
+
+                                // keep track of unused DrLocator rows
+                                if (!usedDrLocator)
+                                {
+                                    unusedSearchElements.Add(searchElement);
+                                }
+                            }
+                            else
+                            {
+                                // TODO: warn
+                            }
+                        }
+                    }
+                    else if (appSearches.Contains(signature))
+                    {
+                        StringCollection appSearchPropertyIds = (StringCollection)appSearches[signature];
+
+                        foreach (string propertyId in appSearchPropertyIds)
+                        {
+                            Wix.Property property = this.EnsureProperty(propertyId);
+
+                            if (ccpSearches.Contains(signature))
+                            {
+                                property.ComplianceCheck = Wix.YesNoType.yes;
+                            }
+
+                            if (!usedSearchElements.Contains(searchElement))
+                            {
+                                property.AddChild(searchElement);
+                                usedSearchElements[searchElement] = null;
+                            }
+                            else if ("RegLocator" == locatorRow.TableDefinition.Name)
+                            {
+                                Wix.RegistrySearchRef registrySearchRef = new Wix.RegistrySearchRef();
+
+                                registrySearchRef.Id = signature;
+
+                                property.AddChild(registrySearchRef);
+                                signatureSearchElements.Add(registrySearchRef);
+                            }
+                            else
+                            {
+                                // TODO: warn about unavailable Ref element
+                            }
+                        }
+                    }
+                    else if (ccpSearches.Contains(signature))
+                    {
+                        if (!usedSearchElements.Contains(searchElement))
+                        {
+                            complianceCheck.AddChild(searchElement);
+                            usedSearchElements[searchElement] = null;
+                        }
+                        else if ("RegLocator" == locatorRow.TableDefinition.Name)
+                        {
+                            Wix.RegistrySearchRef registrySearchRef = new Wix.RegistrySearchRef();
+
+                            registrySearchRef.Id = signature;
+
+                            complianceCheck.AddChild(registrySearchRef);
+                            signatureSearchElements.Add(registrySearchRef);
+                        }
+                        else
+                        {
+                            // TODO: warn about unavailable Ref element
+                        }
+                    }
+                    else
+                    {
+                        if ("DrLocator" == locatorRow.TableDefinition.Name)
+                        {
+                            unusedSearchElements.Add(searchElement);
+                        }
+                        else
+                        {
+                            // TODO: warn
+                            used = false;
+                        }
+                    }
+
+                    // keep track of the search elements for this signature so that nested searches go in the proper parents
+                    if (used)
+                    {
+                        signatureSearchElements.Add(searchElement);
+                    }
+                }
+            }
+
+            foreach (Wix.IParentElement unusedSearchElement in unusedSearchElements)
+            {
+                bool used = false;
+
+                foreach (Wix.ISchemaElement schemaElement in unusedSearchElement.Children)
+                {
+                    Wix.DirectorySearch directorySearch = schemaElement as Wix.DirectorySearch;
+                    if (null != directorySearch)
+                    {
+                        StringCollection appSearchProperties = (StringCollection)appSearches[directorySearch.Id];
+
+                        Wix.ISchemaElement unusedSearchSchemaElement = unusedSearchElement as Wix.ISchemaElement;
+                        if (null != appSearchProperties)
+                        {
+                            Wix.Property property = this.EnsureProperty(appSearchProperties[0]);
+
+                            property.AddChild(unusedSearchSchemaElement);
+                            used = true;
+                            break;
+                        }
+                        else if (ccpSearches.Contains(directorySearch.Id))
+                        {
+                            complianceCheck.AddChild(unusedSearchSchemaElement);
+                            used = true;
+                            break;
+                        }
+                        else
+                        {
+                            // TODO: warn
+                        }
+                    }
+                }
+
+                if (!used)
+                {
+                    // TODO: warn
+                }
+            }
+        }
+
+        /// <summary>
+        /// Finalize the sequence tables.
+        /// </summary>
+        /// <param name="tables">The collection of all tables.</param>
+        /// <remarks>
+        /// Creates the sequence elements.  Occurs during finalization because its
+        /// not known if sequences refer to custom actions or dialogs during decompilation.
+        /// </remarks>
+        private void FinalizeSequenceTables(TableIndexedCollection tables)
+        {
+            // finalize the normal sequence tables
+            if (OutputType.Product == this.outputType && !this.treatProductAsModule)
+            {
+                foreach (SequenceTable sequenceTable in Enum.GetValues(typeof(SequenceTable)))
+                {
+                    // if suppressing UI elements, skip UI-related sequence tables
+                    if (this.suppressUI && ("AdminUISequence" == sequenceTable.ToString() || "InstallUISequence" == sequenceTable.ToString()))
+                    {
+                        continue;
+                    }
+
+                    Table actionsTable = new Table(null, this.tableDefinitions["WixAction"]);
+                    Table table = tables[sequenceTable.ToString()];
+
+                    if (null != table)
+                    {
+                        ArrayList actionRows = new ArrayList();
+                        bool needAbsoluteScheduling = this.suppressRelativeActionSequencing;
+                        WixActionRowCollection nonSequencedActionRows = new WixActionRowCollection();
+                        WixActionRowCollection suppressedRelativeActionRows = new WixActionRowCollection();
+
+                        // create a sorted array of actions in this table
+                        foreach (Row row in table.Rows)
+                        {
+                            WixActionRow actionRow = (WixActionRow)actionsTable.CreateRow(null);
+
+                            actionRow.Action = Convert.ToString(row[0]);
+
+                            if (null != row[1])
+                            {
+                                actionRow.Condition = Convert.ToString(row[1]);
+                            }
+
+                            actionRow.Sequence = Convert.ToInt32(row[2]);
+
+                            actionRow.SequenceTable = sequenceTable;
+
+                            actionRows.Add(actionRow);
+                        }
+                        actionRows.Sort();
+
+                        for (int i = 0; i < actionRows.Count && !needAbsoluteScheduling; i++)
+                        {
+                            WixActionRow actionRow = (WixActionRow)actionRows[i];
+                            WixActionRow standardActionRow = this.standardActions[actionRow.SequenceTable, actionRow.Action];
+
+                            // create actions for custom actions, dialogs, AppSearch when its moved, and standard actions with non-standard conditions
+                            if ("AppSearch" == actionRow.Action || null == standardActionRow || actionRow.Condition != standardActionRow.Condition)
+                            {
+                                WixActionRow previousActionRow = null;
+                                WixActionRow nextActionRow = null;
+
+                                // find the previous action row if there is one
+                                if (0 <= i - 1)
+                                {
+                                    previousActionRow = (WixActionRow)actionRows[i - 1];
+                                }
+
+                                // find the next action row if there is one
+                                if (actionRows.Count > i + 1)
+                                {
+                                    nextActionRow = (WixActionRow)actionRows[i + 1];
+                                }
+
+                                // the logic for setting the before or after attribute for an action:
+                                // 1. If more than one action shares the same sequence number, everything must be absolutely sequenced.
+                                // 2. If the next action is a standard action and is 1 sequence number higher, this action occurs before it.
+                                // 3. If the previous action is a standard action and is 1 sequence number lower, this action occurs after it.
+                                // 4. If this action is not standard and the previous action is 1 sequence number lower and does not occur before this action, this action occurs after it.
+                                // 5. If this action is not standard and the previous action does not have the same sequence number and the next action is 1 sequence number higher, this action occurs before it.
+                                // 6. If this action is AppSearch and has all standard information, ignore it.
+                                // 7. If this action is standard and has a non-standard condition, create the action without any scheduling information.
+                                // 8. Everything must be absolutely sequenced.
+                                if ((null != previousActionRow && actionRow.Sequence == previousActionRow.Sequence) || (null != nextActionRow && actionRow.Sequence == nextActionRow.Sequence))
+                                {
+                                    needAbsoluteScheduling = true;
+                                }
+                                else if (null != nextActionRow && null != this.standardActions[sequenceTable, nextActionRow.Action] && actionRow.Sequence + 1 == nextActionRow.Sequence)
+                                {
+                                    actionRow.Before = nextActionRow.Action;
+                                }
+                                else if (null != previousActionRow && null != this.standardActions[sequenceTable, previousActionRow.Action] && actionRow.Sequence - 1 == previousActionRow.Sequence)
+                                {
+                                    actionRow.After = previousActionRow.Action;
+                                }
+                                else if (null == standardActionRow && null != previousActionRow && actionRow.Sequence - 1 == previousActionRow.Sequence && previousActionRow.Before != actionRow.Action)
+                                {
+                                    actionRow.After = previousActionRow.Action;
+                                }
+                                else if (null == standardActionRow && null != previousActionRow && actionRow.Sequence != previousActionRow.Sequence && null != nextActionRow && actionRow.Sequence + 1 == nextActionRow.Sequence)
+                                {
+                                    actionRow.Before = nextActionRow.Action;
+                                }
+                                else if ("AppSearch" == actionRow.Action && null != standardActionRow && actionRow.Sequence == standardActionRow.Sequence && actionRow.Condition == standardActionRow.Condition)
+                                {
+                                    // ignore an AppSearch row which has the WiX standard sequence and a standard condition
+                                }
+                                else if (null != standardActionRow && actionRow.Condition != standardActionRow.Condition) // standard actions get their standard sequence numbers
+                                {
+                                    nonSequencedActionRows.Add(actionRow);
+                                }
+                                else if (0 < actionRow.Sequence)
+                                {
+                                    needAbsoluteScheduling = true;
+                                }
+                            }
+                            else
+                            {
+                                suppressedRelativeActionRows.Add(actionRow);
+                            }
+                        }
+
+                        // create the actions now that we know if they must be absolutely or relatively scheduled
+                        foreach (WixActionRow actionRow in actionRows)
+                        {
+                            if (needAbsoluteScheduling)
+                            {
+                                // remove any before/after information to ensure this is absolutely sequenced
+                                actionRow.Before = null;
+                                actionRow.After = null;
+                            }
+                            else if (nonSequencedActionRows.Contains(actionRow.SequenceTable, actionRow.Action))
+                            {
+                                // clear the sequence attribute to ensure this action is scheduled without a sequence number (or before/after)
+                                actionRow.Sequence = 0;
+                            }
+                            else if (suppressedRelativeActionRows.Contains(actionRow.SequenceTable, actionRow.Action))
+                            {
+                                // skip the suppressed relatively scheduled action rows
+                                continue;
+                            }
+
+                            // create the action element
+                            this.CreateActionElement(actionRow);
+                        }
+                    }
+                }
+            }
+            else if (OutputType.Module == this.outputType || this.treatProductAsModule) // finalize the Module sequence tables
+            {
+                foreach (SequenceTable sequenceTable in Enum.GetValues(typeof(SequenceTable)))
+                {
+                    // if suppressing UI elements, skip UI-related sequence tables
+                    if (this.suppressUI && ("AdminUISequence" == sequenceTable.ToString() || "InstallUISequence" == sequenceTable.ToString()))
+                    {
+                        continue;
+                    }
+
+                    Table actionsTable = new Table(null, this.tableDefinitions["WixAction"]);
+                    Table table = tables[String.Concat("Module", sequenceTable.ToString())];
+
+                    if (null != table)
+                    {
+                        foreach (Row row in table.Rows)
+                        {
+                            WixActionRow actionRow = (WixActionRow)actionsTable.CreateRow(null);
+
+                            actionRow.Action = Convert.ToString(row[0]);
+
+                            if (null != row[1])
+                            {
+                                actionRow.Sequence = Convert.ToInt32(row[1]);
+                            }
+
+                            if (null != row[2] && null != row[3])
+                            {
+                                switch (Convert.ToInt32(row[3]))
+                                {
+                                    case 0:
+                                        actionRow.Before = Convert.ToString(row[2]);
+                                        break;
+                                    case 1:
+                                        actionRow.After = Convert.ToString(row[2]);
+                                        break;
+                                    default:
+                                        this.core.OnMessage(WixWarnings.IllegalColumnValue(row.SourceLineNumbers, table.Name, row.Fields[3].Column.Name, row[3]));
+                                        break;
+                                }
+                            }
+
+                            if (null != row[4])
+                            {
+                                actionRow.Condition = Convert.ToString(row[4]);
+                            }
+
+                            actionRow.SequenceTable = sequenceTable;
+
+                            // create action elements for non-standard actions
+                            if (null == this.standardActions[actionRow.SequenceTable, actionRow.Action] || null != actionRow.After || null != actionRow.Before)
+                            {
+                                this.CreateActionElement(actionRow);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Finalize the Upgrade table.
+        /// </summary>
+        /// <param name="tables">The collection of all tables.</param>
+        /// <remarks>
+        /// Decompile the rows from the Upgrade and LaunchCondition tables
+        /// created by the MajorUpgrade element.
+        /// </remarks>
+        private void FinalizeUpgradeTable(TableIndexedCollection tables)
+        {
+            Table launchConditionTable = tables["LaunchCondition"];
+            Table upgradeTable = tables["Upgrade"];
+            string downgradeErrorMessage = null;
+            string disallowUpgradeErrorMessage = null;
+            Wix.MajorUpgrade majorUpgrade = new Wix.MajorUpgrade();
+
+            // find the DowngradePreventedCondition launch condition message
+            if (null != launchConditionTable && 0 < launchConditionTable.Rows.Count)
+            {
+                foreach (Row launchRow in launchConditionTable.Rows)
+                {
+                    if (Compiler.DowngradePreventedCondition == Convert.ToString(launchRow[0]))
+                    {
+                        downgradeErrorMessage = Convert.ToString(launchRow[1]);
+                    }
+                    else if (Compiler.UpgradePreventedCondition == Convert.ToString(launchRow[0]))
+                    {
+                        disallowUpgradeErrorMessage = Convert.ToString(launchRow[1]);
+                    }
+                }
+            }
+
+            if (null != upgradeTable && 0 < upgradeTable.Rows.Count)
+            {
+                bool hasMajorUpgrade = false;
+
+                foreach (Row row in upgradeTable.Rows)
+                {
+                    UpgradeRow upgradeRow = (UpgradeRow)row;
+
+                    if (Compiler.UpgradeDetectedProperty == upgradeRow.ActionProperty)
+                    {
+                        hasMajorUpgrade = true;
+                        int attr = upgradeRow.Attributes;
+                        string removeFeatures = upgradeRow.Remove;
+
+                        if (MsiInterop.MsidbUpgradeAttributesVersionMaxInclusive == (attr & MsiInterop.MsidbUpgradeAttributesVersionMaxInclusive))
+                        {
+                            majorUpgrade.AllowSameVersionUpgrades = Wix.YesNoType.yes;
+                        }
+
+                        if (MsiInterop.MsidbUpgradeAttributesMigrateFeatures != (attr & MsiInterop.MsidbUpgradeAttributesMigrateFeatures))
+                        {
+                            majorUpgrade.MigrateFeatures = Wix.YesNoType.no;
+                        }
+
+                        if (MsiInterop.MsidbUpgradeAttributesIgnoreRemoveFailure == (attr & MsiInterop.MsidbUpgradeAttributesIgnoreRemoveFailure))
+                        {
+                            majorUpgrade.IgnoreRemoveFailure = Wix.YesNoType.yes;
+                        }
+
+                        if (!String.IsNullOrEmpty(removeFeatures))
+                        {
+                            majorUpgrade.RemoveFeatures = removeFeatures;
+                        }
+                    }
+                    else if (Compiler.DowngradeDetectedProperty == upgradeRow.ActionProperty)
+                    {
+                        hasMajorUpgrade = true;
+                        majorUpgrade.DowngradeErrorMessage = downgradeErrorMessage;
+                    }
+                }
+
+                if (hasMajorUpgrade)
+                {
+                    if (String.IsNullOrEmpty(downgradeErrorMessage))
+                    {
+                        majorUpgrade.AllowDowngrades = Wix.YesNoType.yes;
+                    }
+
+                    if (!String.IsNullOrEmpty(disallowUpgradeErrorMessage))
+                    {
+                        majorUpgrade.Disallow = Wix.YesNoType.yes;
+                        majorUpgrade.DisallowUpgradeErrorMessage = disallowUpgradeErrorMessage;
+                    }
+
+                    majorUpgrade.Schedule = DetermineMajorUpgradeScheduling(tables);
+                    this.core.RootElement.AddChild(majorUpgrade);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Finalize the Verb table.
+        /// </summary>
+        /// <param name="tables">The collection of all tables.</param>
+        /// <remarks>
+        /// The Extension table is a foreign table for the Verb table, but the
+        /// foreign key is only part of the primary key of the Extension table,
+        /// so it needs special logic to be nested properly.
+        /// </remarks>
+        private void FinalizeVerbTable(TableIndexedCollection tables)
+        {
+            Table extensionTable = tables["Extension"];
+            Table verbTable = tables["Verb"];
+
+            Hashtable extensionElements = new Hashtable();
+
+            if (null != extensionTable)
+            {
+                foreach (Row row in extensionTable.Rows)
+                {
+                    Wix.Extension extension = (Wix.Extension)this.core.GetIndexedElement(row);
+
+                    if (!extensionElements.Contains(row[0]))
+                    {
+                        extensionElements.Add(row[0], new ArrayList());
+                    }
+
+                    ((ArrayList)extensionElements[row[0]]).Add(extension);
+                }
+            }
+
+            if (null != verbTable)
+            {
+                foreach (Row row in verbTable.Rows)
+                {
+                    Wix.Verb verb = (Wix.Verb)this.core.GetIndexedElement(row);
+
+                    ArrayList extensionsArray = (ArrayList)extensionElements[row[0]];
+                    if (null != extensionsArray)
+                    {
+                        foreach (Wix.Extension extension in extensionsArray)
+                        {
+                            extension.AddChild(verb);
+                        }
+                    }
+                    else
+                    {
+                        this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, verbTable.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Extension_", Convert.ToString(row[0]), "Extension"));
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Get the path to a file in the source image.
+        /// </summary>
+        /// <param name="file">The file.</param>
+        /// <returns>The path to the file in the source image.</returns>
+        private string GetSourcePath(Wix.File file)
+        {
+            StringBuilder sourcePath = new StringBuilder();
+
+            Wix.Component component = (Wix.Component)file.ParentElement;
+
+            for (Wix.Directory directory = (Wix.Directory)component.ParentElement; null != directory; directory = directory.ParentElement as Wix.Directory)
+            {
+                string name;
+
+                if (!this.shortNames && null != directory.SourceName)
+                {
+                    name = directory.SourceName;
+                }
+                else if (null != directory.ShortSourceName)
+                {
+                    name = directory.ShortSourceName;
+                }
+                else if (!this.shortNames || null == directory.ShortName)
+                {
+                    name = directory.Name;
+                }
+                else
+                {
+                    name = directory.ShortName;
+                }
+
+                if (0 == sourcePath.Length)
+                {
+                    sourcePath.Append(name);
+                }
+                else
+                {
+                    sourcePath.Insert(0, Path.DirectorySeparatorChar);
+                    sourcePath.Insert(0, name);
+                }
+            }
+
+            return sourcePath.ToString();
+        }
+
+        /// <summary>
+        /// Resolve the dependencies for a table (this is a helper method for GetSortedTableNames).
+        /// </summary>
+        /// <param name="tableName">The name of the table to resolve.</param>
+        /// <param name="unsortedTableNames">The unsorted table names.</param>
+        /// <param name="sortedTableNames">The sorted table names.</param>
+        private void ResolveTableDependencies(string tableName, SortedList unsortedTableNames, StringCollection sortedTableNames)
+        {
+            unsortedTableNames.Remove(tableName);
+
+            foreach (ColumnDefinition columnDefinition in this.tableDefinitions[tableName].Columns)
+            {
+                // no dependency to resolve because this column doesn't reference another table
+                if (null == columnDefinition.KeyTable)
+                {
+                    continue;
+                }
+
+                foreach (string keyTable in columnDefinition.KeyTable.Split(';'))
+                {
+                    if (tableName == keyTable)
+                    {
+                        continue; // self-referencing dependency
+                    }
+                    else if (sortedTableNames.Contains(keyTable))
+                    {
+                        continue; // dependent table has already been sorted
+                    }
+                    else if (!this.tableDefinitions.Contains(keyTable))
+                    {
+                        this.core.OnMessage(WixErrors.MissingTableDefinition(keyTable));
+                    }
+                    else if (unsortedTableNames.Contains(keyTable))
+                    {
+                        this.ResolveTableDependencies(keyTable, unsortedTableNames, sortedTableNames);
+                    }
+                    else
+                    {
+                        // found a circular dependency, so ignore it (this assumes that the tables will
+                        // use a finalize method to nest their elements since the ordering will not be
+                        // deterministic
+                    }
+                }
+            }
+
+            sortedTableNames.Add(tableName);
+        }
+
+        /// <summary>
+        /// Get the names of the tables to process in the order they should be processed, according to their dependencies.
+        /// </summary>
+        /// <returns>A StringCollection containing the ordered table names.</returns>
+        private StringCollection GetSortedTableNames()
+        {
+            StringCollection sortedTableNames = new StringCollection();
+            SortedList unsortedTableNames = new SortedList();
+
+            // index the table names
+            foreach (TableDefinition tableDefinition in this.tableDefinitions)
+            {
+                unsortedTableNames.Add(tableDefinition.Name, tableDefinition.Name);
+            }
+
+            // resolve the dependencies for each table
+            while (0 < unsortedTableNames.Count)
+            {
+                this.ResolveTableDependencies(Convert.ToString(unsortedTableNames.GetByIndex(0)), unsortedTableNames, sortedTableNames);
+            }
+
+            return sortedTableNames;
+        }
+
+        /// <summary>
+        /// Initialize decompilation.
+        /// </summary>
+        /// <param name="tables">The collection of all tables.</param>
+        private void InitializeDecompile(TableIndexedCollection tables)
+        {
+            // reset all the state information
+            this.compressed = false;
+            this.patchTargetFiles.Clear();
+            this.sequenceElements.Clear();
+            this.shortNames = false;
+
+            // set the codepage if its not neutral (0)
+            if (0 != this.codepage)
+            {
+                switch (this.outputType)
+                {
+                    case OutputType.Module:
+                        ((Wix.Module)this.core.RootElement).Codepage = this.codepage.ToString(CultureInfo.InvariantCulture);
+                        break;
+                    case OutputType.PatchCreation:
+                        ((Wix.PatchCreation)this.core.RootElement).Codepage = this.codepage.ToString(CultureInfo.InvariantCulture);
+                        break;
+                    case OutputType.Product:
+                        ((Wix.Product)this.core.RootElement).Codepage = this.codepage.ToString(CultureInfo.InvariantCulture);
+                        break;
+                }
+            }
+
+            // index the rows from the extension libraries
+            Dictionary<string, HashSet<string>> indexedExtensionTables = new Dictionary<string, HashSet<string>>();
+            foreach (IDecompilerExtension extension in this.extensions)
+            {
+                // Get the optional library from the extension with the rows to be removed.
+                Library library = extension.GetLibraryToRemove(this.tableDefinitions);
+                if (null != library)
+                {
+                    foreach (Section section in library.Sections)
+                    {
+                        foreach (Table table in section.Tables)
+                        {
+                            foreach (Row row in table.Rows)
+                            {
+                                string primaryKey;
+                                string tableName;
+
+                                // the Actions table needs to be handled specially
+                                if ("WixAction" == table.Name)
+                                {
+                                    primaryKey = Convert.ToString(row[1]);
+
+                                    if (OutputType.Module == this.outputType)
+                                    {
+                                        tableName = String.Concat("Module", Convert.ToString(row[0]));
+                                    }
+                                    else
+                                    {
+                                        tableName = Convert.ToString(row[0]);
+                                    }
+                                }
+                                else
+                                {
+                                    primaryKey = row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter);
+                                    tableName = table.Name;
+                                }
+
+                                if (null != primaryKey)
+                                {
+                                    HashSet<string> indexedExtensionRows;
+                                    if (!indexedExtensionTables.TryGetValue(tableName, out indexedExtensionRows))
+                                    {
+                                        indexedExtensionRows = new HashSet<string>();
+                                        indexedExtensionTables.Add(tableName, indexedExtensionRows);
+                                    }
+
+                                    indexedExtensionRows.Add(primaryKey);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            // remove the rows from the extension libraries (to allow full round-tripping)
+            foreach (var kvp in indexedExtensionTables)
+            {
+                string tableName = kvp.Key;
+                HashSet<string> indexedExtensionRows = kvp.Value;
+
+                Table table = tables[tableName];
+                if (null != table)
+                {
+                    RowDictionary<Row> originalRows = new RowDictionary<Row>(table);
+
+                    // remove the original rows so that they can be added back if they should remain
+                    table.Rows.Clear();
+
+                    foreach (Row row in originalRows.Values)
+                    {
+                        if (!indexedExtensionRows.Contains(row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter)))
+                        {
+                            table.Rows.Add(row);
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the tables.
+        /// </summary>
+        /// <param name="output">The output being decompiled.</param>
+        private void DecompileTables(Output output)
+        {
+            StringCollection sortedTableNames = this.GetSortedTableNames();
+
+            foreach (string tableName in sortedTableNames)
+            {
+                Table table = output.Tables[tableName];
+
+                // table does not exist in this database or should not be decompiled
+                if (null == table || !this.DecompilableTable(output, tableName))
+                {
+                    continue;
+                }
+
+                this.core.OnMessage(WixVerboses.DecompilingTable(table.Name));
+
+                // empty tables may be kept with EnsureTable if the user set the proper option
+                if (0 == table.Rows.Count && this.suppressDroppingEmptyTables)
+                {
+                    Wix.EnsureTable ensureTable = new Wix.EnsureTable();
+                    ensureTable.Id = table.Name;
+                    this.core.RootElement.AddChild(ensureTable);
+                }
+
+                switch (table.Name)
+                {
+                    case "_SummaryInformation":
+                        this.Decompile_SummaryInformationTable(table);
+                        break;
+                    case "AdminExecuteSequence":
+                    case "AdminUISequence":
+                    case "AdvtExecuteSequence":
+                    case "InstallExecuteSequence":
+                    case "InstallUISequence":
+                    case "ModuleAdminExecuteSequence":
+                    case "ModuleAdminUISequence":
+                    case "ModuleAdvtExecuteSequence":
+                    case "ModuleInstallExecuteSequence":
+                    case "ModuleInstallUISequence":
+                        // handled in FinalizeSequenceTables
+                        break;
+                    case "ActionText":
+                        this.DecompileActionTextTable(table);
+                        break;
+                    case "AdvtUISequence":
+                        this.core.OnMessage(WixWarnings.DeprecatedTable(table.Name));
+                        break;
+                    case "AppId":
+                        this.DecompileAppIdTable(table);
+                        break;
+                    case "AppSearch":
+                        // handled in FinalizeSearchTables
+                        break;
+                    case "BBControl":
+                        this.DecompileBBControlTable(table);
+                        break;
+                    case "Billboard":
+                        this.DecompileBillboardTable(table);
+                        break;
+                    case "Binary":
+                        this.DecompileBinaryTable(table);
+                        break;
+                    case "BindImage":
+                        this.DecompileBindImageTable(table);
+                        break;
+                    case "CCPSearch":
+                        // handled in FinalizeSearchTables
+                        break;
+                    case "CheckBox":
+                        // handled in FinalizeCheckBoxTable
+                        break;
+                    case "Class":
+                        this.DecompileClassTable(table);
+                        break;
+                    case "ComboBox":
+                        this.DecompileComboBoxTable(table);
+                        break;
+                    case "Control":
+                        this.DecompileControlTable(table);
+                        break;
+                    case "ControlCondition":
+                        this.DecompileControlConditionTable(table);
+                        break;
+                    case "ControlEvent":
+                        this.DecompileControlEventTable(table);
+                        break;
+                    case "CreateFolder":
+                        this.DecompileCreateFolderTable(table);
+                        break;
+                    case "CustomAction":
+                        this.DecompileCustomActionTable(table);
+                        break;
+                    case "CompLocator":
+                        this.DecompileCompLocatorTable(table);
+                        break;
+                    case "Complus":
+                        this.DecompileComplusTable(table);
+                        break;
+                    case "Component":
+                        this.DecompileComponentTable(table);
+                        break;
+                    case "Condition":
+                        this.DecompileConditionTable(table);
+                        break;
+                    case "Dialog":
+                        this.DecompileDialogTable(table);
+                        break;
+                    case "Directory":
+                        this.DecompileDirectoryTable(table);
+                        break;
+                    case "DrLocator":
+                        this.DecompileDrLocatorTable(table);
+                        break;
+                    case "DuplicateFile":
+                        this.DecompileDuplicateFileTable(table);
+                        break;
+                    case "Environment":
+                        this.DecompileEnvironmentTable(table);
+                        break;
+                    case "Error":
+                        this.DecompileErrorTable(table);
+                        break;
+                    case "EventMapping":
+                        this.DecompileEventMappingTable(table);
+                        break;
+                    case "Extension":
+                        this.DecompileExtensionTable(table);
+                        break;
+                    case "ExternalFiles":
+                        this.DecompileExternalFilesTable(table);
+                        break;
+                    case "FamilyFileRanges":
+                        // handled in FinalizeFamilyFileRangesTable
+                        break;
+                    case "Feature":
+                        this.DecompileFeatureTable(table);
+                        break;
+                    case "FeatureComponents":
+                        this.DecompileFeatureComponentsTable(table);
+                        break;
+                    case "File":
+                        this.DecompileFileTable(table);
+                        break;
+                    case "FileSFPCatalog":
+                        this.DecompileFileSFPCatalogTable(table);
+                        break;
+                    case "Font":
+                        this.DecompileFontTable(table);
+                        break;
+                    case "Icon":
+                        this.DecompileIconTable(table);
+                        break;
+                    case "ImageFamilies":
+                        this.DecompileImageFamiliesTable(table);
+                        break;
+                    case "IniFile":
+                        this.DecompileIniFileTable(table);
+                        break;
+                    case "IniLocator":
+                        this.DecompileIniLocatorTable(table);
+                        break;
+                    case "IsolatedComponent":
+                        this.DecompileIsolatedComponentTable(table);
+                        break;
+                    case "LaunchCondition":
+                        this.DecompileLaunchConditionTable(table);
+                        break;
+                    case "ListBox":
+                        this.DecompileListBoxTable(table);
+                        break;
+                    case "ListView":
+                        this.DecompileListViewTable(table);
+                        break;
+                    case "LockPermissions":
+                        this.DecompileLockPermissionsTable(table);
+                        break;
+                    case "Media":
+                        this.DecompileMediaTable(table);
+                        break;
+                    case "MIME":
+                        this.DecompileMIMETable(table);
+                        break;
+                    case "ModuleAdvtUISequence":
+                        this.core.OnMessage(WixWarnings.DeprecatedTable(table.Name));
+                        break;
+                    case "ModuleComponents":
+                        // handled by DecompileComponentTable (since the ModuleComponents table
+                        // rows are created by nesting components under the Module element)
+                        break;
+                    case "ModuleConfiguration":
+                        this.DecompileModuleConfigurationTable(table);
+                        break;
+                    case "ModuleDependency":
+                        this.DecompileModuleDependencyTable(table);
+                        break;
+                    case "ModuleExclusion":
+                        this.DecompileModuleExclusionTable(table);
+                        break;
+                    case "ModuleIgnoreTable":
+                        this.DecompileModuleIgnoreTableTable(table);
+                        break;
+                    case "ModuleSignature":
+                        this.DecompileModuleSignatureTable(table);
+                        break;
+                    case "ModuleSubstitution":
+                        this.DecompileModuleSubstitutionTable(table);
+                        break;
+                    case "MoveFile":
+                        this.DecompileMoveFileTable(table);
+                        break;
+                    case "MsiAssembly":
+                        // handled in FinalizeFileTable
+                        break;
+                    case "MsiDigitalCertificate":
+                        this.DecompileMsiDigitalCertificateTable(table);
+                        break;
+                    case "MsiDigitalSignature":
+                        this.DecompileMsiDigitalSignatureTable(table);
+                        break;
+                    case "MsiEmbeddedChainer":
+                        this.DecompileMsiEmbeddedChainerTable(table);
+                        break;
+                    case "MsiEmbeddedUI":
+                        this.DecompileMsiEmbeddedUITable(table);
+                        break;
+                    case "MsiLockPermissionsEx":
+                        this.DecompileMsiLockPermissionsExTable(table);
+                        break;
+                    case "MsiPackageCertificate":
+                        this.DecompileMsiPackageCertificateTable(table);
+                        break;
+                    case "MsiPatchCertificate":
+                        this.DecompileMsiPatchCertificateTable(table);
+                        break;
+                    case "MsiShortcutProperty":
+                        this.DecompileMsiShortcutPropertyTable(table);
+                        break;
+                    case "ODBCAttribute":
+                        this.DecompileODBCAttributeTable(table);
+                        break;
+                    case "ODBCDataSource":
+                        this.DecompileODBCDataSourceTable(table);
+                        break;
+                    case "ODBCDriver":
+                        this.DecompileODBCDriverTable(table);
+                        break;
+                    case "ODBCSourceAttribute":
+                        this.DecompileODBCSourceAttributeTable(table);
+                        break;
+                    case "ODBCTranslator":
+                        this.DecompileODBCTranslatorTable(table);
+                        break;
+                    case "PatchMetadata":
+                        this.DecompilePatchMetadataTable(table);
+                        break;
+                    case "PatchSequence":
+                        this.DecompilePatchSequenceTable(table);
+                        break;
+                    case "ProgId":
+                        this.DecompileProgIdTable(table);
+                        break;
+                    case "Properties":
+                        this.DecompilePropertiesTable(table);
+                        break;
+                    case "Property":
+                        this.DecompilePropertyTable(table);
+                        break;
+                    case "PublishComponent":
+                        this.DecompilePublishComponentTable(table);
+                        break;
+                    case "RadioButton":
+                        this.DecompileRadioButtonTable(table);
+                        break;
+                    case "Registry":
+                        this.DecompileRegistryTable(table);
+                        break;
+                    case "RegLocator":
+                        this.DecompileRegLocatorTable(table);
+                        break;
+                    case "RemoveFile":
+                        this.DecompileRemoveFileTable(table);
+                        break;
+                    case "RemoveIniFile":
+                        this.DecompileRemoveIniFileTable(table);
+                        break;
+                    case "RemoveRegistry":
+                        this.DecompileRemoveRegistryTable(table);
+                        break;
+                    case "ReserveCost":
+                        this.DecompileReserveCostTable(table);
+                        break;
+                    case "SelfReg":
+                        this.DecompileSelfRegTable(table);
+                        break;
+                    case "ServiceControl":
+                        this.DecompileServiceControlTable(table);
+                        break;
+                    case "ServiceInstall":
+                        this.DecompileServiceInstallTable(table);
+                        break;
+                    case "SFPCatalog":
+                        this.DecompileSFPCatalogTable(table);
+                        break;
+                    case "Shortcut":
+                        this.DecompileShortcutTable(table);
+                        break;
+                    case "Signature":
+                        this.DecompileSignatureTable(table);
+                        break;
+                    case "TargetFiles_OptionalData":
+                        this.DecompileTargetFiles_OptionalDataTable(table);
+                        break;
+                    case "TargetImages":
+                        this.DecompileTargetImagesTable(table);
+                        break;
+                    case "TextStyle":
+                        this.DecompileTextStyleTable(table);
+                        break;
+                    case "TypeLib":
+                        this.DecompileTypeLibTable(table);
+                        break;
+                    case "Upgrade":
+                        this.DecompileUpgradeTable(table);
+                        break;
+                    case "UpgradedFiles_OptionalData":
+                        this.DecompileUpgradedFiles_OptionalDataTable(table);
+                        break;
+                    case "UpgradedFilesToIgnore":
+                        this.DecompileUpgradedFilesToIgnoreTable(table);
+                        break;
+                    case "UpgradedImages":
+                        this.DecompileUpgradedImagesTable(table);
+                        break;
+                    case "UIText":
+                        this.DecompileUITextTable(table);
+                        break;
+                    case "Verb":
+                        this.DecompileVerbTable(table);
+                        break;
+                    default:
+                        DecompilerExtension extension = (DecompilerExtension)this.extensionsByTableName[table.Name];
+
+                        if (null != extension)
+                        {
+                            extension.DecompileTable(table);
+                        }
+                        else if (!this.suppressCustomTables)
+                        {
+                            this.DecompileCustomTable(table);
+                        }
+                        break;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Determine if a particular table should be decompiled with the current settings.
+        /// </summary>
+        /// <param name="output">The output being decompiled.</param>
+        /// <param name="tableName">The name of a table.</param>
+        /// <returns>true if the table should be decompiled; false otherwise.</returns>
+        private bool DecompilableTable(Output output, string tableName)
+        {
+            switch (tableName)
+            {
+                case "ActionText":
+                case "BBControl":
+                case "Billboard":
+                case "CheckBox":
+                case "Control":
+                case "ControlCondition":
+                case "ControlEvent":
+                case "Dialog":
+                case "Error":
+                case "EventMapping":
+                case "RadioButton":
+                case "TextStyle":
+                case "UIText":
+                    return !this.suppressUI;
+                case "ModuleAdminExecuteSequence":
+                case "ModuleAdminUISequence":
+                case "ModuleAdvtExecuteSequence":
+                case "ModuleAdvtUISequence":
+                case "ModuleComponents":
+                case "ModuleConfiguration":
+                case "ModuleDependency":
+                case "ModuleIgnoreTable":
+                case "ModuleInstallExecuteSequence":
+                case "ModuleInstallUISequence":
+                case "ModuleExclusion":
+                case "ModuleSignature":
+                case "ModuleSubstitution":
+                    if (OutputType.Module != output.Type)
+                    {
+                        this.core.OnMessage(WixWarnings.SkippingMergeModuleTable(output.SourceLineNumbers, tableName));
+                        return false;
+                    }
+                    else
+                    {
+                        return true;
+                    }
+                case "ExternalFiles":
+                case "FamilyFileRanges":
+                case "ImageFamilies":
+                case "PatchMetadata":
+                case "PatchSequence":
+                case "Properties":
+                case "TargetFiles_OptionalData":
+                case "TargetImages":
+                case "UpgradedFiles_OptionalData":
+                case "UpgradedFilesToIgnore":
+                case "UpgradedImages":
+                    if (OutputType.PatchCreation != output.Type)
+                    {
+                        this.core.OnMessage(WixWarnings.SkippingPatchCreationTable(output.SourceLineNumbers, tableName));
+                        return false;
+                    }
+                    else
+                    {
+                        return true;
+                    }
+                case "MsiPatchHeaders":
+                case "MsiPatchMetadata":
+                case "MsiPatchOldAssemblyName":
+                case "MsiPatchOldAssemblyFile":
+                case "MsiPatchSequence":
+                case "Patch":
+                case "PatchPackage":
+                    this.core.OnMessage(WixWarnings.PatchTable(output.SourceLineNumbers, tableName));
+                    return false;
+                case "_SummaryInformation":
+                    return true;
+                case "_Validation":
+                case "MsiAssemblyName":
+                case "MsiFileHash":
+                    return false;
+                default: // all other tables are allowed in any output except for a patch creation package
+                    if (OutputType.PatchCreation == output.Type)
+                    {
+                        this.core.OnMessage(WixWarnings.IllegalPatchCreationTable(output.SourceLineNumbers, tableName));
+                        return false;
+                    }
+                    else
+                    {
+                        return true;
+                    }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the _SummaryInformation table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void Decompile_SummaryInformationTable(Table table)
+        {
+            if (OutputType.Module == this.outputType || OutputType.Product == this.outputType)
+            {
+                Wix.Package package = new Wix.Package();
+
+                foreach (Row row in table.Rows)
+                {
+                    string value = Convert.ToString(row[1]);
+
+                    if (null != value && 0 < value.Length)
+                    {
+                        switch (Convert.ToInt32(row[0]))
+                        {
+                            case 1:
+                                if ("1252" != value)
+                                {
+                                    package.SummaryCodepage = value;
+                                }
+                                break;
+                            case 3:
+                                package.Description = value;
+                                break;
+                            case 4:
+                                package.Manufacturer = value;
+                                break;
+                            case 5:
+                                if ("Installer" != value)
+                                {
+                                    package.Keywords = value;
+                                }
+                                break;
+                            case 6:
+                                package.Comments = value;
+                                break;
+                            case 7:
+                                string[] template = value.Split(';');
+                                if (0 < template.Length && 0 < template[template.Length - 1].Length)
+                                {
+                                    package.Languages = template[template.Length - 1];
+                                }
+
+                                if (1 < template.Length && null != template[0] && 0 < template[0].Length)
+                                {
+                                    switch (template[0])
+                                    {
+                                        case "Intel":
+                                            package.Platform = WixToolset.Data.Serialize.Package.PlatformType.x86;
+                                            break;
+                                        case "Intel64":
+                                            package.Platform = WixToolset.Data.Serialize.Package.PlatformType.ia64;
+                                            break;
+                                        case "x64":
+                                            package.Platform = WixToolset.Data.Serialize.Package.PlatformType.x64;
+                                            break;
+                                    }
+                                }
+                                break;
+                            case 9:
+                                if (OutputType.Module == this.outputType)
+                                {
+                                    this.modularizationGuid = value;
+                                    package.Id = value;
+                                }
+                                break;
+                            case 14:
+                                package.InstallerVersion = Convert.ToInt32(row[1], CultureInfo.InvariantCulture);
+                                break;
+                            case 15:
+                                int wordCount = Convert.ToInt32(row[1], CultureInfo.InvariantCulture);
+                                if (0x1 == (wordCount & 0x1))
+                                {
+                                    this.shortNames = true;
+                                    package.ShortNames = Wix.YesNoType.yes;
+                                }
+
+                                if (0x2 == (wordCount & 0x2))
+                                {
+                                    this.compressed = true;
+
+                                    if (OutputType.Product == this.outputType)
+                                    {
+                                        package.Compressed = Wix.YesNoType.yes;
+                                    }
+                                }
+
+                                if (0x4 == (wordCount & 0x4))
+                                {
+                                    package.AdminImage = Wix.YesNoType.yes;
+                                }
+
+                                if (0x8 == (wordCount & 0x8))
+                                {
+                                    package.InstallPrivileges = Wix.Package.InstallPrivilegesType.limited;
+                                }
+
+                                break;
+                            case 19:
+                                int security = Convert.ToInt32(row[1], CultureInfo.InvariantCulture);
+                                switch (security)
+                                {
+                                    case 0:
+                                        package.ReadOnly = Wix.YesNoDefaultType.no;
+                                        break;
+                                    case 4:
+                                        package.ReadOnly = Wix.YesNoDefaultType.yes;
+                                        break;
+                                }
+                                break;
+                        }
+                    }
+                }
+
+                this.core.RootElement.AddChild(package);
+            }
+            else
+            {
+                Wix.PatchInformation patchInformation = new Wix.PatchInformation();
+
+                foreach (Row row in table.Rows)
+                {
+                    int propertyId = Convert.ToInt32(row[0]);
+                    string value = Convert.ToString(row[1]);
+
+                    if (null != row[1] && 0 < value.Length)
+                    {
+                        switch (propertyId)
+                        {
+                            case 1:
+                                if ("1252" != value)
+                                {
+                                    patchInformation.SummaryCodepage = value;
+                                }
+                                break;
+                            case 3:
+                                patchInformation.Description = value;
+                                break;
+                            case 4:
+                                patchInformation.Manufacturer = value;
+                                break;
+                            case 5:
+                                if ("Installer,Patching,PCP,Database" != value)
+                                {
+                                    patchInformation.Keywords = value;
+                                }
+                                break;
+                            case 6:
+                                patchInformation.Comments = value;
+                                break;
+                            case 7:
+                                string[] template = value.Split(';');
+                                if (0 < template.Length && 0 < template[template.Length - 1].Length)
+                                {
+                                    patchInformation.Languages = template[template.Length - 1];
+                                }
+
+                                if (1 < template.Length && null != template[0] && 0 < template[0].Length)
+                                {
+                                    patchInformation.Platforms = template[0];
+                                }
+                                break;
+                            case 15:
+                                int wordCount = Convert.ToInt32(value, CultureInfo.InvariantCulture);
+                                if (0x1 == (wordCount & 0x1))
+                                {
+                                    patchInformation.ShortNames = Wix.YesNoType.yes;
+                                }
+
+                                if (0x2 == (wordCount & 0x2))
+                                {
+                                    patchInformation.Compressed = Wix.YesNoType.yes;
+                                }
+
+                                if (0x4 == (wordCount & 0x4))
+                                {
+                                    patchInformation.AdminImage = Wix.YesNoType.yes;
+                                }
+                                break;
+                            case 19:
+                                int security = Convert.ToInt32(value, CultureInfo.InvariantCulture);
+                                switch (security)
+                                {
+                                    case 0:
+                                        patchInformation.ReadOnly = Wix.YesNoDefaultType.no;
+                                        break;
+                                    case 4:
+                                        patchInformation.ReadOnly = Wix.YesNoDefaultType.yes;
+                                        break;
+                                }
+                                break;
+                        }
+                    }
+                }
+
+                this.core.RootElement.AddChild(patchInformation);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the ActionText table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileActionTextTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.ProgressText progressText = new Wix.ProgressText();
+
+                progressText.Action = Convert.ToString(row[0]);
+
+                if (null != row[1])
+                {
+                    progressText.Content = Convert.ToString(row[1]);
+                }
+
+                if (null != row[2])
+                {
+                    progressText.Template = Convert.ToString(row[2]);
+                }
+
+                this.core.UIElement.AddChild(progressText);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the AppId table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileAppIdTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.AppId appId = new Wix.AppId();
+
+                appId.Advertise = Wix.YesNoType.yes;
+
+                appId.Id = Convert.ToString(row[0]);
+
+                if (null != row[1])
+                {
+                    appId.RemoteServerName = Convert.ToString(row[1]);
+                }
+
+                if (null != row[2])
+                {
+                    appId.LocalService = Convert.ToString(row[2]);
+                }
+
+                if (null != row[3])
+                {
+                    appId.ServiceParameters = Convert.ToString(row[3]);
+                }
+
+                if (null != row[4])
+                {
+                    appId.DllSurrogate = Convert.ToString(row[4]);
+                }
+
+                if (null != row[5] && Int32.Equals(row[5], 1))
+                {
+                    appId.ActivateAtStorage = Wix.YesNoType.yes;
+                }
+
+                if (null != row[6] && Int32.Equals(row[6], 1))
+                {
+                    appId.RunAsInteractiveUser = Wix.YesNoType.yes;
+                }
+
+                this.core.RootElement.AddChild(appId);
+                this.core.IndexElement(row, appId);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the BBControl table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileBBControlTable(Table table)
+        {
+            foreach (BBControlRow bbControlRow in table.Rows)
+            {
+                Wix.Control control = new Wix.Control();
+
+                control.Id = bbControlRow.BBControl;
+
+                control.Type = bbControlRow.Type;
+
+                control.X = bbControlRow.X;
+
+                control.Y = bbControlRow.Y;
+
+                control.Width = bbControlRow.Width;
+
+                control.Height = bbControlRow.Height;
+
+                if (null != bbControlRow[7])
+                {
+                    SetControlAttributes(bbControlRow.Attributes, control);
+                }
+
+                if (null != bbControlRow.Text)
+                {
+                    control.Text = bbControlRow.Text;
+                }
+
+                Wix.Billboard billboard = (Wix.Billboard)this.core.GetIndexedElement("Billboard", bbControlRow.Billboard);
+                if (null != billboard)
+                {
+                    billboard.AddChild(control);
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(bbControlRow.SourceLineNumbers, table.Name, bbControlRow.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Billboard_", bbControlRow.Billboard, "Billboard"));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the Billboard table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileBillboardTable(Table table)
+        {
+            Hashtable billboardActions = new Hashtable();
+            SortedList billboards = new SortedList();
+
+            foreach (Row row in table.Rows)
+            {
+                Wix.Billboard billboard = new Wix.Billboard();
+
+                billboard.Id = Convert.ToString(row[0]);
+
+                billboard.Feature = Convert.ToString(row[1]);
+
+                this.core.IndexElement(row, billboard);
+                billboards.Add(String.Format(CultureInfo.InvariantCulture, "{0}|{1:0000000000}", row[0], row[3]), row);
+            }
+
+            foreach (Row row in billboards.Values)
+            {
+                Wix.Billboard billboard = (Wix.Billboard)this.core.GetIndexedElement(row);
+                Wix.BillboardAction billboardAction = (Wix.BillboardAction)billboardActions[row[2]];
+
+                if (null == billboardAction)
+                {
+                    billboardAction = new Wix.BillboardAction();
+
+                    billboardAction.Id = Convert.ToString(row[2]);
+
+                    this.core.UIElement.AddChild(billboardAction);
+                    billboardActions.Add(row[2], billboardAction);
+                }
+
+                billboardAction.AddChild(billboard);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the Binary table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileBinaryTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.Binary binary = new Wix.Binary();
+
+                binary.Id = Convert.ToString(row[0]);
+
+                binary.SourceFile = Convert.ToString(row[1]);
+
+                this.core.RootElement.AddChild(binary);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the BindImage table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileBindImageTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.File file = (Wix.File)this.core.GetIndexedElement("File", Convert.ToString(row[0]));
+
+                if (null != file)
+                {
+                    file.BindPath = Convert.ToString(row[1]);
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "File_", Convert.ToString(row[0]), "File"));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the Class table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileClassTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.Class wixClass = new Wix.Class();
+
+                wixClass.Advertise = Wix.YesNoType.yes;
+
+                wixClass.Id = Convert.ToString(row[0]);
+
+                switch (Convert.ToString(row[1]))
+                {
+                    case "LocalServer":
+                        wixClass.Context = Wix.Class.ContextType.LocalServer;
+                        break;
+                    case "LocalServer32":
+                        wixClass.Context = Wix.Class.ContextType.LocalServer32;
+                        break;
+                    case "InprocServer":
+                        wixClass.Context = Wix.Class.ContextType.InprocServer;
+                        break;
+                    case "InprocServer32":
+                        wixClass.Context = Wix.Class.ContextType.InprocServer32;
+                        break;
+                    default:
+                        this.core.OnMessage(WixWarnings.IllegalColumnValue(row.SourceLineNumbers, table.Name, row.Fields[1].Column.Name, row[1]));
+                        break;
+                }
+
+                // ProgId children are handled in FinalizeProgIdTable
+
+                if (null != row[4])
+                {
+                    wixClass.Description = Convert.ToString(row[4]);
+                }
+
+                if (null != row[5])
+                {
+                    wixClass.AppId = Convert.ToString(row[5]);
+                }
+
+                if (null != row[6])
+                {
+                    string[] fileTypeMaskStrings = (Convert.ToString(row[6])).Split(';');
+
+                    try
+                    {
+                        foreach (string fileTypeMaskString in fileTypeMaskStrings)
+                        {
+                            string[] fileTypeMaskParts = fileTypeMaskString.Split(',');
+
+                            if (4 == fileTypeMaskParts.Length)
+                            {
+                                Wix.FileTypeMask fileTypeMask = new Wix.FileTypeMask();
+
+                                fileTypeMask.Offset = Convert.ToInt32(fileTypeMaskParts[0], CultureInfo.InvariantCulture);
+
+                                fileTypeMask.Mask = fileTypeMaskParts[2];
+
+                                fileTypeMask.Value = fileTypeMaskParts[3];
+
+                                wixClass.AddChild(fileTypeMask);
+                            }
+                            else
+                            {
+                                // TODO: warn
+                            }
+                        }
+                    }
+                    catch (FormatException)
+                    {
+                        this.core.OnMessage(WixWarnings.IllegalColumnValue(row.SourceLineNumbers, table.Name, row.Fields[6].Column.Name, row[6]));
+                    }
+                    catch (OverflowException)
+                    {
+                        this.core.OnMessage(WixWarnings.IllegalColumnValue(row.SourceLineNumbers, table.Name, row.Fields[6].Column.Name, row[6]));
+                    }
+                }
+
+                if (null != row[7])
+                {
+                    wixClass.Icon = Convert.ToString(row[7]);
+                }
+
+                if (null != row[8])
+                {
+                    wixClass.IconIndex = Convert.ToInt32(row[8]);
+                }
+
+                if (null != row[9])
+                {
+                    wixClass.Handler = Convert.ToString(row[9]);
+                }
+
+                if (null != row[10])
+                {
+                    wixClass.Argument = Convert.ToString(row[10]);
+                }
+
+                if (null != row[12])
+                {
+                    if (1 == Convert.ToInt32(row[12]))
+                    {
+                        wixClass.RelativePath = Wix.YesNoType.yes;
+                    }
+                    else
+                    {
+                        this.core.OnMessage(WixWarnings.IllegalColumnValue(row.SourceLineNumbers, table.Name, row.Fields[12].Column.Name, row[12]));
+                    }
+                }
+
+                Wix.Component component = (Wix.Component)this.core.GetIndexedElement("Component", Convert.ToString(row[2]));
+                if (null != component)
+                {
+                    component.AddChild(wixClass);
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", Convert.ToString(row[2]), "Component"));
+                }
+
+                this.core.IndexElement(row, wixClass);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the ComboBox table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileComboBoxTable(Table table)
+        {
+            Wix.ComboBox comboBox = null;
+            SortedList comboBoxRows = new SortedList();
+
+            // sort the combo boxes by their property and order
+            foreach (Row row in table.Rows)
+            {
+                comboBoxRows.Add(String.Concat("{0}|{1:0000000000}", row[0], row[1]), row);
+            }
+
+            foreach (Row row in comboBoxRows.Values)
+            {
+                if (null == comboBox || Convert.ToString(row[0]) != comboBox.Property)
+                {
+                    comboBox = new Wix.ComboBox();
+
+                    comboBox.Property = Convert.ToString(row[0]);
+
+                    this.core.UIElement.AddChild(comboBox);
+                }
+
+                Wix.ListItem listItem = new Wix.ListItem();
+
+                listItem.Value = Convert.ToString(row[2]);
+
+                if (null != row[3])
+                {
+                    listItem.Text = Convert.ToString(row[3]);
+                }
+
+                comboBox.AddChild(listItem);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the Control table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileControlTable(Table table)
+        {
+            foreach (ControlRow controlRow in table.Rows)
+            {
+                Wix.Control control = new Wix.Control();
+
+                control.Id = controlRow.Control;
+
+                control.Type = controlRow.Type;
+
+                control.X = controlRow.X;
+
+                control.Y = controlRow.Y;
+
+                control.Width = controlRow.Width;
+
+                control.Height = controlRow.Height;
+
+                if (null != controlRow[7])
+                {
+                    string[] specialAttributes;
+
+                    // sets various common attributes like Disabled, Indirect, Integer, ...
+                    SetControlAttributes(controlRow.Attributes, control);
+
+                    switch (control.Type)
+                    {
+                        case "Bitmap":
+                            specialAttributes = MsiInterop.BitmapControlAttributes;
+                            break;
+                        case "CheckBox":
+                            specialAttributes = MsiInterop.CheckboxControlAttributes;
+                            break;
+                        case "ComboBox":
+                            specialAttributes = MsiInterop.ComboboxControlAttributes;
+                            break;
+                        case "DirectoryCombo":
+                            specialAttributes = MsiInterop.VolumeControlAttributes;
+                            break;
+                        case "Edit":
+                            specialAttributes = MsiInterop.EditControlAttributes;
+                            break;
+                        case "Icon":
+                            specialAttributes = MsiInterop.IconControlAttributes;
+                            break;
+                        case "ListBox":
+                            specialAttributes = MsiInterop.ListboxControlAttributes;
+                            break;
+                        case "ListView":
+                            specialAttributes = MsiInterop.ListviewControlAttributes;
+                            break;
+                        case "MaskedEdit":
+                            specialAttributes = MsiInterop.EditControlAttributes;
+                            break;
+                        case "PathEdit":
+                            specialAttributes = MsiInterop.EditControlAttributes;
+                            break;
+                        case "ProgressBar":
+                            specialAttributes = MsiInterop.ProgressControlAttributes;
+                            break;
+                        case "PushButton":
+                            specialAttributes = MsiInterop.ButtonControlAttributes;
+                            break;
+                        case "RadioButtonGroup":
+                            specialAttributes = MsiInterop.RadioControlAttributes;
+                            break;
+                        case "Text":
+                            specialAttributes = MsiInterop.TextControlAttributes;
+                            break;
+                        case "VolumeCostList":
+                            specialAttributes = MsiInterop.VolumeControlAttributes;
+                            break;
+                        case "VolumeSelectCombo":
+                            specialAttributes = MsiInterop.VolumeControlAttributes;
+                            break;
+                        default:
+                            specialAttributes = null;
+                            break;
+                    }
+
+                    if (null != specialAttributes)
+                    {
+                        bool iconSizeSet = false;
+
+                        for (int i = 16; 32 > i; i++)
+                        {
+                            if (1 == ((controlRow.Attributes >> i) & 1))
+                            {
+                                string attribute = null;
+
+                                if (specialAttributes.Length > (i - 16))
+                                {
+                                    attribute = specialAttributes[i - 16];
+                                }
+
+                                // unknown attribute
+                                if (null == attribute)
+                                {
+                                    this.core.OnMessage(WixWarnings.IllegalColumnValue(controlRow.SourceLineNumbers, table.Name, controlRow.Fields[7].Column.Name, controlRow.Attributes));
+                                    continue;
+                                }
+
+                                switch (attribute)
+                                {
+                                    case "Bitmap":
+                                        control.Bitmap = Wix.YesNoType.yes;
+                                        break;
+                                    case "CDROM":
+                                        control.CDROM = Wix.YesNoType.yes;
+                                        break;
+                                    case "ComboList":
+                                        control.ComboList = Wix.YesNoType.yes;
+                                        break;
+                                    case "ElevationShield":
+                                        control.ElevationShield = Wix.YesNoType.yes;
+                                        break;
+                                    case "Fixed":
+                                        control.Fixed = Wix.YesNoType.yes;
+                                        break;
+                                    case "FixedSize":
+                                        control.FixedSize = Wix.YesNoType.yes;
+                                        break;
+                                    case "Floppy":
+                                        control.Floppy = Wix.YesNoType.yes;
+                                        break;
+                                    case "FormatSize":
+                                        control.FormatSize = Wix.YesNoType.yes;
+                                        break;
+                                    case "HasBorder":
+                                        control.HasBorder = Wix.YesNoType.yes;
+                                        break;
+                                    case "Icon":
+                                        control.Icon = Wix.YesNoType.yes;
+                                        break;
+                                    case "Icon16":
+                                        if (iconSizeSet)
+                                        {
+                                            control.IconSize = Wix.Control.IconSizeType.Item48;
+                                        }
+                                        else
+                                        {
+                                            iconSizeSet = true;
+                                            control.IconSize = Wix.Control.IconSizeType.Item16;
+                                        }
+                                        break;
+                                    case "Icon32":
+                                        if (iconSizeSet)
+                                        {
+                                            control.IconSize = Wix.Control.IconSizeType.Item48;
+                                        }
+                                        else
+                                        {
+                                            iconSizeSet = true;
+                                            control.IconSize = Wix.Control.IconSizeType.Item32;
+                                        }
+                                        break;
+                                    case "Image":
+                                        control.Image = Wix.YesNoType.yes;
+                                        break;
+                                    case "Multiline":
+                                        control.Multiline = Wix.YesNoType.yes;
+                                        break;
+                                    case "NoPrefix":
+                                        control.NoPrefix = Wix.YesNoType.yes;
+                                        break;
+                                    case "NoWrap":
+                                        control.NoWrap = Wix.YesNoType.yes;
+                                        break;
+                                    case "Password":
+                                        control.Password = Wix.YesNoType.yes;
+                                        break;
+                                    case "ProgressBlocks":
+                                        control.ProgressBlocks = Wix.YesNoType.yes;
+                                        break;
+                                    case "PushLike":
+                                        control.PushLike = Wix.YesNoType.yes;
+                                        break;
+                                    case "RAMDisk":
+                                        control.RAMDisk = Wix.YesNoType.yes;
+                                        break;
+                                    case "Remote":
+                                        control.Remote = Wix.YesNoType.yes;
+                                        break;
+                                    case "Removable":
+                                        control.Removable = Wix.YesNoType.yes;
+                                        break;
+                                    case "ShowRollbackCost":
+                                        control.ShowRollbackCost = Wix.YesNoType.yes;
+                                        break;
+                                    case "Sorted":
+                                        control.Sorted = Wix.YesNoType.yes;
+                                        break;
+                                    case "Transparent":
+                                        control.Transparent = Wix.YesNoType.yes;
+                                        break;
+                                    case "UserLanguage":
+                                        control.UserLanguage = Wix.YesNoType.yes;
+                                        break;
+                                    default:
+                                        throw new InvalidOperationException(String.Format(CultureInfo.CurrentUICulture, WixStrings.EXP_UnknowControlAttribute, attribute));
+                                }
+                            }
+                        }
+                    }
+                    else if (0 < (controlRow.Attributes & 0xFFFF0000))
+                    {
+                        this.core.OnMessage(WixWarnings.IllegalColumnValue(controlRow.SourceLineNumbers, table.Name, controlRow.Fields[7].Column.Name, controlRow.Attributes));
+                    }
+                }
+
+                // FinalizeCheckBoxTable adds Control/@Property|@CheckBoxPropertyRef
+                if (null != controlRow.Property && 0 != String.CompareOrdinal("CheckBox", control.Type))
+                {
+                    control.Property = controlRow.Property;
+                }
+
+                if (null != controlRow.Text)
+                {
+                    control.Text = controlRow.Text;
+                }
+
+                if (null != controlRow.Help)
+                {
+                    string[] help = controlRow.Help.Split('|');
+
+                    if (2 == help.Length)
+                    {
+                        if (0 < help[0].Length)
+                        {
+                            control.ToolTip = help[0];
+                        }
+
+                        if (0 < help[1].Length)
+                        {
+                            control.Help = help[1];
+                        }
+                    }
+                }
+
+                this.core.IndexElement(controlRow, control);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the ControlCondition table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileControlConditionTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.Condition condition = new Wix.Condition();
+
+                switch (Convert.ToString(row[2]))
+                {
+                    case "Default":
+                        condition.Action = Wix.Condition.ActionType.@default;
+                        break;
+                    case "Disable":
+                        condition.Action = Wix.Condition.ActionType.disable;
+                        break;
+                    case "Enable":
+                        condition.Action = Wix.Condition.ActionType.enable;
+                        break;
+                    case "Hide":
+                        condition.Action = Wix.Condition.ActionType.hide;
+                        break;
+                    case "Show":
+                        condition.Action = Wix.Condition.ActionType.show;
+                        break;
+                    default:
+                        this.core.OnMessage(WixWarnings.IllegalColumnValue(row.SourceLineNumbers, table.Name, row.Fields[2].Column.Name, row[2]));
+                        break;
+                }
+
+                condition.Content = Convert.ToString(row[3]);
+
+                Wix.Control control = (Wix.Control)this.core.GetIndexedElement("Control", Convert.ToString(row[0]), Convert.ToString(row[1]));
+                if (null != control)
+                {
+                    control.AddChild(condition);
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Dialog_", Convert.ToString(row[0]), "Control_", Convert.ToString(row[1]), "Control"));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the ControlEvent table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileControlEventTable(Table table)
+        {
+            SortedList controlEvents = new SortedList();
+
+            foreach (Row row in table.Rows)
+            {
+                Wix.Publish publish = new Wix.Publish();
+
+                string publishEvent = Convert.ToString(row[2]);
+                if (publishEvent.StartsWith("[", StringComparison.Ordinal) && publishEvent.EndsWith("]", StringComparison.Ordinal))
+                {
+                    publish.Property = publishEvent.Substring(1, publishEvent.Length - 2);
+
+                    if ("{}" != Convert.ToString(row[3]))
+                    {
+                        publish.Value = Convert.ToString(row[3]);
+                    }
+                }
+                else
+                {
+                    publish.Event = publishEvent;
+                    publish.Value = Convert.ToString(row[3]);
+                }
+
+                if (null != row[4])
+                {
+                    publish.Content = Convert.ToString(row[4]);
+                }
+
+                controlEvents.Add(String.Format(CultureInfo.InvariantCulture, "{0}|{1}|{2:0000000000}|{3}|{4}|{5}", row[0], row[1], (null == row[5] ? 0 : Convert.ToInt32(row[5])), row[2], row[3], row[4]), row);
+
+                this.core.IndexElement(row, publish);
+            }
+
+            foreach (Row row in controlEvents.Values)
+            {
+                Wix.Control control = (Wix.Control)this.core.GetIndexedElement("Control", Convert.ToString(row[0]), Convert.ToString(row[1]));
+                Wix.Publish publish = (Wix.Publish)this.core.GetIndexedElement(row);
+
+                if (null != control)
+                {
+                    control.AddChild(publish);
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Dialog_", Convert.ToString(row[0]), "Control_", Convert.ToString(row[1]), "Control"));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile a custom table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileCustomTable(Table table)
+        {
+            if (0 < table.Rows.Count || this.suppressDroppingEmptyTables)
+            {
+                Wix.CustomTable customTable = new Wix.CustomTable();
+
+                this.core.OnMessage(WixWarnings.DecompilingAsCustomTable(table.Rows[0].SourceLineNumbers, table.Name));
+
+                customTable.Id = table.Name;
+
+                foreach (ColumnDefinition columnDefinition in table.Definition.Columns)
+                {
+                    Wix.Column column = new Wix.Column();
+
+                    column.Id = columnDefinition.Name;
+
+                    if (ColumnCategory.Unknown != columnDefinition.Category)
+                    {
+                        switch (columnDefinition.Category)
+                        {
+                            case ColumnCategory.Text:
+                                column.Category = Wix.Column.CategoryType.Text;
+                                break;
+                            case ColumnCategory.UpperCase:
+                                column.Category = Wix.Column.CategoryType.UpperCase;
+                                break;
+                            case ColumnCategory.LowerCase:
+                                column.Category = Wix.Column.CategoryType.LowerCase;
+                                break;
+                            case ColumnCategory.Integer:
+                                column.Category = Wix.Column.CategoryType.Integer;
+                                break;
+                            case ColumnCategory.DoubleInteger:
+                                column.Category = Wix.Column.CategoryType.DoubleInteger;
+                                break;
+                            case ColumnCategory.TimeDate:
+                                column.Category = Wix.Column.CategoryType.TimeDate;
+                                break;
+                            case ColumnCategory.Identifier:
+                                column.Category = Wix.Column.CategoryType.Identifier;
+                                break;
+                            case ColumnCategory.Property:
+                                column.Category = Wix.Column.CategoryType.Property;
+                                break;
+                            case ColumnCategory.Filename:
+                                column.Category = Wix.Column.CategoryType.Filename;
+                                break;
+                            case ColumnCategory.WildCardFilename:
+                                column.Category = Wix.Column.CategoryType.WildCardFilename;
+                                break;
+                            case ColumnCategory.Path:
+                                column.Category = Wix.Column.CategoryType.Path;
+                                break;
+                            case ColumnCategory.Paths:
+                                column.Category = Wix.Column.CategoryType.Paths;
+                                break;
+                            case ColumnCategory.AnyPath:
+                                column.Category = Wix.Column.CategoryType.AnyPath;
+                                break;
+                            case ColumnCategory.DefaultDir:
+                                column.Category = Wix.Column.CategoryType.DefaultDir;
+                                break;
+                            case ColumnCategory.RegPath:
+                                column.Category = Wix.Column.CategoryType.RegPath;
+                                break;
+                            case ColumnCategory.Formatted:
+                                column.Category = Wix.Column.CategoryType.Formatted;
+                                break;
+                            case ColumnCategory.FormattedSDDLText:
+                                column.Category = Wix.Column.CategoryType.FormattedSddl;
+                                break;
+                            case ColumnCategory.Template:
+                                column.Category = Wix.Column.CategoryType.Template;
+                                break;
+                            case ColumnCategory.Condition:
+                                column.Category = Wix.Column.CategoryType.Condition;
+                                break;
+                            case ColumnCategory.Guid:
+                                column.Category = Wix.Column.CategoryType.Guid;
+                                break;
+                            case ColumnCategory.Version:
+                                column.Category = Wix.Column.CategoryType.Version;
+                                break;
+                            case ColumnCategory.Language:
+                                column.Category = Wix.Column.CategoryType.Language;
+                                break;
+                            case ColumnCategory.Binary:
+                                column.Category = Wix.Column.CategoryType.Binary;
+                                break;
+                            case ColumnCategory.CustomSource:
+                                column.Category = Wix.Column.CategoryType.CustomSource;
+                                break;
+                            case ColumnCategory.Cabinet:
+                                column.Category = Wix.Column.CategoryType.Cabinet;
+                                break;
+                            case ColumnCategory.Shortcut:
+                                column.Category = Wix.Column.CategoryType.Shortcut;
+                                break;
+                            default:
+                                throw new InvalidOperationException(String.Format(CultureInfo.CurrentUICulture, WixStrings.EXP_UnknownCustomColumnCategory, columnDefinition.Category.ToString()));
+                        }
+                    }
+
+                    if (null != columnDefinition.Description)
+                    {
+                        column.Description = columnDefinition.Description;
+                    }
+
+                    if (columnDefinition.IsKeyColumnSet)
+                    {
+                        column.KeyColumn = columnDefinition.KeyColumn;
+                    }
+
+                    if (null != columnDefinition.KeyTable)
+                    {
+                        column.KeyTable = columnDefinition.KeyTable;
+                    }
+
+                    if (columnDefinition.IsLocalizable)
+                    {
+                        column.Localizable = Wix.YesNoType.yes;
+                    }
+
+                    if (columnDefinition.IsMaxValueSet)
+                    {
+                        column.MaxValue = columnDefinition.MaxValue;
+                    }
+
+                    if (columnDefinition.IsMinValueSet)
+                    {
+                        column.MinValue = columnDefinition.MinValue;
+                    }
+
+                    if (ColumnModularizeType.None != columnDefinition.ModularizeType)
+                    {
+                        switch (columnDefinition.ModularizeType)
+                        {
+                            case ColumnModularizeType.Column:
+                                column.Modularize = Wix.Column.ModularizeType.Column;
+                                break;
+                            case ColumnModularizeType.Condition:
+                                column.Modularize = Wix.Column.ModularizeType.Condition;
+                                break;
+                            case ColumnModularizeType.Icon:
+                                column.Modularize = Wix.Column.ModularizeType.Icon;
+                                break;
+                            case ColumnModularizeType.Property:
+                                column.Modularize = Wix.Column.ModularizeType.Property;
+                                break;
+                            case ColumnModularizeType.SemicolonDelimited:
+                                column.Modularize = Wix.Column.ModularizeType.SemicolonDelimited;
+                                break;
+                            default:
+                                throw new InvalidOperationException(String.Format(CultureInfo.CurrentUICulture, WixStrings.EXP_UnknownCustomColumnModularizationType, columnDefinition.ModularizeType.ToString()));
+                        }
+                    }
+
+                    if (columnDefinition.Nullable)
+                    {
+                        column.Nullable = Wix.YesNoType.yes;
+                    }
+
+                    if (columnDefinition.PrimaryKey)
+                    {
+                        column.PrimaryKey = Wix.YesNoType.yes;
+                    }
+
+                    if (null != columnDefinition.Possibilities)
+                    {
+                        column.Set = columnDefinition.Possibilities;
+                    }
+
+                    if (ColumnType.Unknown != columnDefinition.Type)
+                    {
+                        switch (columnDefinition.Type)
+                        {
+                            case ColumnType.Localized:
+                                column.Localizable = Wix.YesNoType.yes;
+                                column.Type = Wix.Column.TypeType.@string;
+                                break;
+                            case ColumnType.Number:
+                                column.Type = Wix.Column.TypeType.@int;
+                                break;
+                            case ColumnType.Object:
+                                column.Type = Wix.Column.TypeType.binary;
+                                break;
+                            case ColumnType.Preserved:
+                            case ColumnType.String:
+                                column.Type = Wix.Column.TypeType.@string;
+                                break;
+                            default:
+                                throw new InvalidOperationException(String.Format(CultureInfo.CurrentUICulture, WixStrings.EXP_UnknownCustomColumnType, columnDefinition.Type.ToString()));
+                        }
+                    }
+
+                    column.Width = columnDefinition.Length;
+
+                    customTable.AddChild(column);
+                }
+
+                foreach (Row row in table.Rows)
+                {
+                    Wix.Row wixRow = new Wix.Row();
+
+                    foreach (Field field in row.Fields)
+                    {
+                        Wix.Data data = new Wix.Data();
+
+                        data.Column = field.Column.Name;
+
+                        data.Content = Convert.ToString(field.Data, CultureInfo.InvariantCulture);
+
+                        wixRow.AddChild(data);
+                    }
+
+                    customTable.AddChild(wixRow);
+                }
+
+                this.core.RootElement.AddChild(customTable);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the CreateFolder table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileCreateFolderTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.CreateFolder createFolder = new Wix.CreateFolder();
+
+                createFolder.Directory = Convert.ToString(row[0]);
+
+                Wix.Component component = (Wix.Component)this.core.GetIndexedElement("Component", Convert.ToString(row[1]));
+                if (null != component)
+                {
+                    component.AddChild(createFolder);
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", Convert.ToString(row[1]), "Component"));
+                }
+                this.core.IndexElement(row, createFolder);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the CustomAction table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileCustomActionTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.CustomAction customAction = new Wix.CustomAction();
+
+                customAction.Id = Convert.ToString(row[0]);
+
+                int type = Convert.ToInt32(row[1]);
+
+                if (MsiInterop.MsidbCustomActionTypeHideTarget == (type & MsiInterop.MsidbCustomActionTypeHideTarget))
+                {
+                    customAction.HideTarget = Wix.YesNoType.yes;
+                }
+
+                if (MsiInterop.MsidbCustomActionTypeNoImpersonate == (type & MsiInterop.MsidbCustomActionTypeNoImpersonate))
+                {
+                    customAction.Impersonate = Wix.YesNoType.no;
+                }
+
+                if (MsiInterop.MsidbCustomActionTypeTSAware == (type & MsiInterop.MsidbCustomActionTypeTSAware))
+                {
+                    customAction.TerminalServerAware = Wix.YesNoType.yes;
+                }
+
+                if (MsiInterop.MsidbCustomActionType64BitScript == (type & MsiInterop.MsidbCustomActionType64BitScript))
+                {
+                    customAction.Win64 = Wix.YesNoType.yes;
+                }
+
+                switch (type & MsiInterop.MsidbCustomActionTypeExecuteBits)
+                {
+                    case 0:
+                        // this is the default value
+                        break;
+                    case MsiInterop.MsidbCustomActionTypeFirstSequence:
+                        customAction.Execute = Wix.CustomAction.ExecuteType.firstSequence;
+                        break;
+                    case MsiInterop.MsidbCustomActionTypeOncePerProcess:
+                        customAction.Execute = Wix.CustomAction.ExecuteType.oncePerProcess;
+                        break;
+                    case MsiInterop.MsidbCustomActionTypeClientRepeat:
+                        customAction.Execute = Wix.CustomAction.ExecuteType.secondSequence;
+                        break;
+                    case MsiInterop.MsidbCustomActionTypeInScript:
+                        customAction.Execute = Wix.CustomAction.ExecuteType.deferred;
+                        break;
+                    case MsiInterop.MsidbCustomActionTypeInScript + MsiInterop.MsidbCustomActionTypeRollback:
+                        customAction.Execute = Wix.CustomAction.ExecuteType.rollback;
+                        break;
+                    case MsiInterop.MsidbCustomActionTypeInScript + MsiInterop.MsidbCustomActionTypeCommit:
+                        customAction.Execute = Wix.CustomAction.ExecuteType.commit;
+                        break;
+                    default:
+                        this.core.OnMessage(WixWarnings.IllegalColumnValue(row.SourceLineNumbers, table.Name, row.Fields[1].Column.Name, row[1]));
+                        break;
+                }
+
+                switch (type & MsiInterop.MsidbCustomActionTypeReturnBits)
+                {
+                    case 0:
+                        // this is the default value
+                        break;
+                    case MsiInterop.MsidbCustomActionTypeContinue:
+                        customAction.Return = Wix.CustomAction.ReturnType.ignore;
+                        break;
+                    case MsiInterop.MsidbCustomActionTypeAsync:
+                        customAction.Return = Wix.CustomAction.ReturnType.asyncWait;
+                        break;
+                    case MsiInterop.MsidbCustomActionTypeAsync + MsiInterop.MsidbCustomActionTypeContinue:
+                        customAction.Return = Wix.CustomAction.ReturnType.asyncNoWait;
+                        break;
+                    default:
+                        this.core.OnMessage(WixWarnings.IllegalColumnValue(row.SourceLineNumbers, table.Name, row.Fields[1].Column.Name, row[1]));
+                        break;
+                }
+
+                int source = type & MsiInterop.MsidbCustomActionTypeSourceBits;
+                switch (source)
+                {
+                    case MsiInterop.MsidbCustomActionTypeBinaryData:
+                        customAction.BinaryKey = Convert.ToString(row[2]);
+                        break;
+                    case MsiInterop.MsidbCustomActionTypeSourceFile:
+                        if (null != row[2])
+                        {
+                            customAction.FileKey = Convert.ToString(row[2]);
+                        }
+                        break;
+                    case MsiInterop.MsidbCustomActionTypeDirectory:
+                        if (null != row[2])
+                        {
+                            customAction.Directory = Convert.ToString(row[2]);
+                        }
+                        break;
+                    case MsiInterop.MsidbCustomActionTypeProperty:
+                        customAction.Property = Convert.ToString(row[2]);
+                        break;
+                    default:
+                        this.core.OnMessage(WixWarnings.IllegalColumnValue(row.SourceLineNumbers, table.Name, row.Fields[1].Column.Name, row[1]));
+                        break;
+                }
+
+                switch (type & MsiInterop.MsidbCustomActionTypeTargetBits)
+                {
+                    case MsiInterop.MsidbCustomActionTypeDll:
+                        customAction.DllEntry = Convert.ToString(row[3]);
+                        break;
+                    case MsiInterop.MsidbCustomActionTypeExe:
+                        customAction.ExeCommand = Convert.ToString(row[3]);
+                        break;
+                    case MsiInterop.MsidbCustomActionTypeTextData:
+                        if (MsiInterop.MsidbCustomActionTypeSourceFile == source)
+                        {
+                            customAction.Error = Convert.ToString(row[3]);
+                        }
+                        else
+                        {
+                            customAction.Value = Convert.ToString(row[3]);
+                        }
+                        break;
+                    case MsiInterop.MsidbCustomActionTypeJScript:
+                        if (MsiInterop.MsidbCustomActionTypeDirectory == source)
+                        {
+                            customAction.Script = Wix.CustomAction.ScriptType.jscript;
+                            customAction.Content = Convert.ToString(row[3]);
+                        }
+                        else
+                        {
+                            customAction.JScriptCall = Convert.ToString(row[3]);
+                        }
+                        break;
+                    case MsiInterop.MsidbCustomActionTypeVBScript:
+                        if (MsiInterop.MsidbCustomActionTypeDirectory == source)
+                        {
+                            customAction.Script = Wix.CustomAction.ScriptType.vbscript;
+                            customAction.Content = Convert.ToString(row[3]);
+                        }
+                        else
+                        {
+                            customAction.VBScriptCall = Convert.ToString(row[3]);
+                        }
+                        break;
+                    case MsiInterop.MsidbCustomActionTypeInstall:
+                        this.core.OnMessage(WixWarnings.NestedInstall(row.SourceLineNumbers, table.Name, row.Fields[1].Column.Name, row[1]));
+                        continue;
+                    default:
+                        this.core.OnMessage(WixWarnings.IllegalColumnValue(row.SourceLineNumbers, table.Name, row.Fields[1].Column.Name, row[1]));
+                        break;
+                }
+
+                int extype = 4 < row.Fields.Length && null != row[4] ? Convert.ToInt32(row[4]) : 0;
+                if (MsiInterop.MsidbCustomActionTypePatchUninstall == (extype & MsiInterop.MsidbCustomActionTypePatchUninstall))
+                {
+                    customAction.PatchUninstall = Wix.YesNoType.yes;
+                }
+
+                this.core.RootElement.AddChild(customAction);
+                this.core.IndexElement(row, customAction);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the CompLocator table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileCompLocatorTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.ComponentSearch componentSearch = new Wix.ComponentSearch();
+
+                componentSearch.Id = Convert.ToString(row[0]);
+
+                componentSearch.Guid = Convert.ToString(row[1]);
+
+                if (null != row[2])
+                {
+                    switch (Convert.ToInt32(row[2]))
+                    {
+                        case MsiInterop.MsidbLocatorTypeDirectory:
+                            componentSearch.Type = Wix.ComponentSearch.TypeType.directory;
+                            break;
+                        case MsiInterop.MsidbLocatorTypeFileName:
+                            // this is the default value
+                            break;
+                        default:
+                            this.core.OnMessage(WixWarnings.IllegalColumnValue(row.SourceLineNumbers, table.Name, row.Fields[2].Column.Name, row[2]));
+                            break;
+                    }
+                }
+
+                this.core.IndexElement(row, componentSearch);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the Complus table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileComplusTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                if (null != row[1])
+                {
+                    Wix.Component component = (Wix.Component)this.core.GetIndexedElement("Component", Convert.ToString(row[0]));
+
+                    if (null != component)
+                    {
+                        component.ComPlusFlags = Convert.ToInt32(row[1]);
+                    }
+                    else
+                    {
+                        this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", Convert.ToString(row[0]), "Component"));
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the Component table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileComponentTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.Component component = new Wix.Component();
+
+                component.Id = Convert.ToString(row[0]);
+
+                component.Guid = Convert.ToString(row[1]);
+
+                int attributes = Convert.ToInt32(row[3]);
+
+                if (MsiInterop.MsidbComponentAttributesSourceOnly == (attributes & MsiInterop.MsidbComponentAttributesSourceOnly))
+                {
+                    component.Location = Wix.Component.LocationType.source;
+                }
+                else if (MsiInterop.MsidbComponentAttributesOptional == (attributes & MsiInterop.MsidbComponentAttributesOptional))
+                {
+                    component.Location = Wix.Component.LocationType.either;
+                }
+
+                if (MsiInterop.MsidbComponentAttributesSharedDllRefCount == (attributes & MsiInterop.MsidbComponentAttributesSharedDllRefCount))
+                {
+                    component.SharedDllRefCount = Wix.YesNoType.yes;
+                }
+
+                if (MsiInterop.MsidbComponentAttributesPermanent == (attributes & MsiInterop.MsidbComponentAttributesPermanent))
+                {
+                    component.Permanent = Wix.YesNoType.yes;
+                }
+
+                if (MsiInterop.MsidbComponentAttributesTransitive == (attributes & MsiInterop.MsidbComponentAttributesTransitive))
+                {
+                    component.Transitive = Wix.YesNoType.yes;
+                }
+
+                if (MsiInterop.MsidbComponentAttributesNeverOverwrite == (attributes & MsiInterop.MsidbComponentAttributesNeverOverwrite))
+                {
+                    component.NeverOverwrite = Wix.YesNoType.yes;
+                }
+
+                if (MsiInterop.MsidbComponentAttributes64bit == (attributes & MsiInterop.MsidbComponentAttributes64bit))
+                {
+                    component.Win64 = Wix.YesNoType.yes;
+                }
+
+                if (MsiInterop.MsidbComponentAttributesDisableRegistryReflection == (attributes & MsiInterop.MsidbComponentAttributesDisableRegistryReflection))
+                {
+                    component.DisableRegistryReflection = Wix.YesNoType.yes;
+                }
+
+                if (MsiInterop.MsidbComponentAttributesUninstallOnSupersedence == (attributes & MsiInterop.MsidbComponentAttributesUninstallOnSupersedence))
+                {
+                    component.UninstallWhenSuperseded = Wix.YesNoType.yes;
+                }
+
+                if (MsiInterop.MsidbComponentAttributesShared == (attributes & MsiInterop.MsidbComponentAttributesShared))
+                {
+                    component.Shared = Wix.YesNoType.yes;
+                }
+
+                if (null != row[4])
+                {
+                    Wix.Condition condition = new Wix.Condition();
+
+                    condition.Content = Convert.ToString(row[4]);
+
+                    component.AddChild(condition);
+                }
+
+                Wix.Directory directory = (Wix.Directory)this.core.GetIndexedElement("Directory", Convert.ToString(row[2]));
+                if (null != directory)
+                {
+                    directory.AddChild(component);
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Directory_", Convert.ToString(row[2]), "Directory"));
+                }
+                this.core.IndexElement(row, component);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the Condition table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileConditionTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.Condition condition = new Wix.Condition();
+
+                condition.Level = Convert.ToInt32(row[1]);
+
+                if (null != row[2])
+                {
+                    condition.Content = Convert.ToString(row[2]);
+                }
+
+                Wix.Feature feature = (Wix.Feature)this.core.GetIndexedElement("Feature", Convert.ToString(row[0]));
+                if (null != feature)
+                {
+                    feature.AddChild(condition);
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Feature_", Convert.ToString(row[0]), "Feature"));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the Dialog table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileDialogTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.Dialog dialog = new Wix.Dialog();
+
+                dialog.Id = Convert.ToString(row[0]);
+
+                dialog.X = Convert.ToInt32(row[1]);
+
+                dialog.Y = Convert.ToInt32(row[2]);
+
+                dialog.Width = Convert.ToInt32(row[3]);
+
+                dialog.Height = Convert.ToInt32(row[4]);
+
+                if (null != row[5])
+                {
+                    int attributes = Convert.ToInt32(row[5]);
+
+                    if (0 == (attributes & MsiInterop.MsidbDialogAttributesVisible))
+                    {
+                        dialog.Hidden = Wix.YesNoType.yes;
+                    }
+
+                    if (0 == (attributes & MsiInterop.MsidbDialogAttributesModal))
+                    {
+                        dialog.Modeless = Wix.YesNoType.yes;
+                    }
+
+                    if (0 == (attributes & MsiInterop.MsidbDialogAttributesMinimize))
+                    {
+                        dialog.NoMinimize = Wix.YesNoType.yes;
+                    }
+
+                    if (MsiInterop.MsidbDialogAttributesSysModal == (attributes & MsiInterop.MsidbDialogAttributesSysModal))
+                    {
+                        dialog.SystemModal = Wix.YesNoType.yes;
+                    }
+
+                    if (MsiInterop.MsidbDialogAttributesKeepModeless == (attributes & MsiInterop.MsidbDialogAttributesKeepModeless))
+                    {
+                        dialog.KeepModeless = Wix.YesNoType.yes;
+                    }
+
+                    if (MsiInterop.MsidbDialogAttributesTrackDiskSpace == (attributes & MsiInterop.MsidbDialogAttributesTrackDiskSpace))
+                    {
+                        dialog.TrackDiskSpace = Wix.YesNoType.yes;
+                    }
+
+                    if (MsiInterop.MsidbDialogAttributesUseCustomPalette == (attributes & MsiInterop.MsidbDialogAttributesUseCustomPalette))
+                    {
+                        dialog.CustomPalette = Wix.YesNoType.yes;
+                    }
+
+                    if (MsiInterop.MsidbDialogAttributesRTLRO == (attributes & MsiInterop.MsidbDialogAttributesRTLRO))
+                    {
+                        dialog.RightToLeft = Wix.YesNoType.yes;
+                    }
+
+                    if (MsiInterop.MsidbDialogAttributesRightAligned == (attributes & MsiInterop.MsidbDialogAttributesRightAligned))
+                    {
+                        dialog.RightAligned = Wix.YesNoType.yes;
+                    }
+
+                    if (MsiInterop.MsidbDialogAttributesLeftScroll == (attributes & MsiInterop.MsidbDialogAttributesLeftScroll))
+                    {
+                        dialog.LeftScroll = Wix.YesNoType.yes;
+                    }
+
+                    if (MsiInterop.MsidbDialogAttributesError == (attributes & MsiInterop.MsidbDialogAttributesError))
+                    {
+                        dialog.ErrorDialog = Wix.YesNoType.yes;
+                    }
+                }
+
+                if (null != row[6])
+                {
+                    dialog.Title = Convert.ToString(row[6]);
+                }
+
+                this.core.UIElement.AddChild(dialog);
+                this.core.IndexElement(row, dialog);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the Directory table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileDirectoryTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.Directory directory = new Wix.Directory();
+
+                directory.Id = Convert.ToString(row[0]);
+
+                string[] names = Installer.GetNames(Convert.ToString(row[2]));
+
+                if (String.Equals(directory.Id, "TARGETDIR", StringComparison.Ordinal) && !String.Equals(names[0], "SourceDir", StringComparison.Ordinal))
+                {
+                    this.core.OnMessage(WixWarnings.TargetDirCorrectedDefaultDir());
+                    directory.Name = "SourceDir";
+                }
+                else
+                {
+                    if (null != names[0] && "." != names[0])
+                    {
+                        if (null != names[1])
+                        {
+                            directory.ShortName = names[0];
+                        }
+                        else
+                        {
+                            directory.Name = names[0];
+                        }
+                    }
+
+                    if (null != names[1])
+                    {
+                        directory.Name = names[1];
+                    }
+                }
+
+                if (null != names[2])
+                {
+                    if (null != names[3])
+                    {
+                        directory.ShortSourceName = names[2];
+                    }
+                    else
+                    {
+                        directory.SourceName = names[2];
+                    }
+                }
+
+                if (null != names[3])
+                {
+                    directory.SourceName = names[3];
+                }
+
+                this.core.IndexElement(row, directory);
+            }
+
+            // nest the directories
+            foreach (Row row in table.Rows)
+            {
+                Wix.Directory directory = (Wix.Directory)this.core.GetIndexedElement(row);
+
+                if (null == row[1])
+                {
+                    this.core.RootElement.AddChild(directory);
+                }
+                else
+                {
+                    Wix.Directory parentDirectory = (Wix.Directory)this.core.GetIndexedElement("Directory", Convert.ToString(row[1]));
+
+                    if (null == parentDirectory)
+                    {
+                        this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Directory_Parent", Convert.ToString(row[1]), "Directory"));
+                    }
+                    else if (parentDirectory == directory) // another way to specify a root directory
+                    {
+                        this.core.RootElement.AddChild(directory);
+                    }
+                    else
+                    {
+                        parentDirectory.AddChild(directory);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the DrLocator table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileDrLocatorTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.DirectorySearch directorySearch = new Wix.DirectorySearch();
+
+                directorySearch.Id = Convert.ToString(row[0]);
+
+                if (null != row[2])
+                {
+                    directorySearch.Path = Convert.ToString(row[2]);
+                }
+
+                if (null != row[3])
+                {
+                    directorySearch.Depth = Convert.ToInt32(row[3]);
+                }
+
+                this.core.IndexElement(row, directorySearch);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the DuplicateFile table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileDuplicateFileTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.CopyFile copyFile = new Wix.CopyFile();
+
+                copyFile.Id = Convert.ToString(row[0]);
+
+                copyFile.FileId = Convert.ToString(row[2]);
+
+                if (null != row[3])
+                {
+                    string[] names = Installer.GetNames(Convert.ToString(row[3]));
+                    if (null != names[0] && null != names[1])
+                    {
+                        copyFile.DestinationShortName = names[0];
+                        copyFile.DestinationName = names[1];
+                    }
+                    else if (null != names[0])
+                    {
+                        copyFile.DestinationName = names[0];
+                    }
+                }
+
+                // destination directory/property is set in FinalizeDuplicateMoveFileTables
+
+                Wix.Component component = (Wix.Component)this.core.GetIndexedElement("Component", Convert.ToString(row[1]));
+                if (null != component)
+                {
+                    component.AddChild(copyFile);
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", Convert.ToString(row[1]), "Component"));
+                }
+                this.core.IndexElement(row, copyFile);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the Environment table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileEnvironmentTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.Environment environment = new Wix.Environment();
+
+                environment.Id = Convert.ToString(row[0]);
+
+                bool done = false;
+                bool permanent = true;
+                string name = Convert.ToString(row[1]);
+                for (int i = 0; i < name.Length && !done; i++)
+                {
+                    switch (name[i])
+                    {
+                        case '=':
+                            environment.Action = Wix.Environment.ActionType.set;
+                            break;
+                        case '+':
+                            environment.Action = Wix.Environment.ActionType.create;
+                            break;
+                        case '-':
+                            permanent = false;
+                            break;
+                        case '!':
+                            environment.Action = Wix.Environment.ActionType.remove;
+                            break;
+                        case '*':
+                            environment.System = Wix.YesNoType.yes;
+                            break;
+                        default:
+                            environment.Name = name.Substring(i);
+                            done = true;
+                            break;
+                    }
+                }
+
+                if (permanent)
+                {
+                    environment.Permanent = Wix.YesNoType.yes;
+                }
+
+                if (null != row[2])
+                {
+                    string value = Convert.ToString(row[2]);
+
+                    if (value.StartsWith("[~]", StringComparison.Ordinal))
+                    {
+                        environment.Part = Wix.Environment.PartType.last;
+
+                        if (3 < value.Length)
+                        {
+                            environment.Separator = value.Substring(3, 1);
+                            environment.Value = value.Substring(4);
+                        }
+                    }
+                    else if (value.EndsWith("[~]", StringComparison.Ordinal))
+                    {
+                        environment.Part = Wix.Environment.PartType.first;
+
+                        if (3 < value.Length)
+                        {
+                            environment.Separator = value.Substring(value.Length - 4, 1);
+                            environment.Value = value.Substring(0, value.Length - 4);
+                        }
+                    }
+                    else
+                    {
+                        environment.Value = value;
+                    }
+                }
+
+                Wix.Component component = (Wix.Component)this.core.GetIndexedElement("Component", Convert.ToString(row[3]));
+                if (null != component)
+                {
+                    component.AddChild(environment);
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", Convert.ToString(row[3]), "Component"));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the Error table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileErrorTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.Error error = new Wix.Error();
+
+                error.Id = Convert.ToInt32(row[0]);
+
+                error.Content = Convert.ToString(row[1]);
+
+                this.core.UIElement.AddChild(error);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the EventMapping table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileEventMappingTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.Subscribe subscribe = new Wix.Subscribe();
+
+                subscribe.Event = Convert.ToString(row[2]);
+
+                subscribe.Attribute = Convert.ToString(row[3]);
+
+                Wix.Control control = (Wix.Control)this.core.GetIndexedElement("Control", Convert.ToString(row[0]), Convert.ToString(row[1]));
+                if (null != control)
+                {
+                    control.AddChild(subscribe);
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Dialog_", Convert.ToString(row[0]), "Control_", Convert.ToString(row[1]), "Control"));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the Extension table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileExtensionTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.Extension extension = new Wix.Extension();
+
+                extension.Advertise = Wix.YesNoType.yes;
+
+                extension.Id = Convert.ToString(row[0]);
+
+                if (null != row[3])
+                {
+                    Wix.MIME mime = (Wix.MIME)this.core.GetIndexedElement("MIME", Convert.ToString(row[3]));
+
+                    if (null != mime)
+                    {
+                        mime.Default = Wix.YesNoType.yes;
+                    }
+                    else
+                    {
+                        this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "MIME_", Convert.ToString(row[3]), "MIME"));
+                    }
+                }
+
+                if (null != row[2])
+                {
+                    Wix.ProgId progId = (Wix.ProgId)this.core.GetIndexedElement("ProgId", Convert.ToString(row[2]));
+
+                    if (null != progId)
+                    {
+                        progId.AddChild(extension);
+                    }
+                    else
+                    {
+                        this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "ProgId_", Convert.ToString(row[2]), "ProgId"));
+                    }
+                }
+                else
+                {
+                    Wix.Component component = (Wix.Component)this.core.GetIndexedElement("Component", Convert.ToString(row[1]));
+
+                    if (null != component)
+                    {
+                        component.AddChild(extension);
+                    }
+                    else
+                    {
+                        this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", Convert.ToString(row[1]), "Component"));
+                    }
+                }
+
+                this.core.IndexElement(row, extension);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the ExternalFiles table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileExternalFilesTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.ExternalFile externalFile = new Wix.ExternalFile();
+
+                externalFile.File = Convert.ToString(row[1]);
+
+                externalFile.Source = Convert.ToString(row[2]);
+
+                if (null != row[3])
+                {
+                    string[] symbolPaths = (Convert.ToString(row[3])).Split(';');
+
+                    foreach (string symbolPathString in symbolPaths)
+                    {
+                        Wix.SymbolPath symbolPath = new Wix.SymbolPath();
+
+                        symbolPath.Path = symbolPathString;
+
+                        externalFile.AddChild(symbolPath);
+                    }
+                }
+
+                if (null != row[4] && null != row[5])
+                {
+                    string[] ignoreOffsets = (Convert.ToString(row[4])).Split(',');
+                    string[] ignoreLengths = (Convert.ToString(row[5])).Split(',');
+
+                    if (ignoreOffsets.Length == ignoreLengths.Length)
+                    {
+                        for (int i = 0; i < ignoreOffsets.Length; i++)
+                        {
+                            Wix.IgnoreRange ignoreRange = new Wix.IgnoreRange();
+
+                            if (ignoreOffsets[i].StartsWith("0x", StringComparison.Ordinal))
+                            {
+                                ignoreRange.Offset = Convert.ToInt32(ignoreOffsets[i].Substring(2), 16);
+                            }
+                            else
+                            {
+                                ignoreRange.Offset = Convert.ToInt32(ignoreOffsets[i], CultureInfo.InvariantCulture);
+                            }
+
+                            if (ignoreLengths[i].StartsWith("0x", StringComparison.Ordinal))
+                            {
+                                ignoreRange.Length = Convert.ToInt32(ignoreLengths[i].Substring(2), 16);
+                            }
+                            else
+                            {
+                                ignoreRange.Length = Convert.ToInt32(ignoreLengths[i], CultureInfo.InvariantCulture);
+                            }
+
+                            externalFile.AddChild(ignoreRange);
+                        }
+                    }
+                    else
+                    {
+                        // TODO: warn
+                    }
+                }
+                else if (null != row[4] || null != row[5])
+                {
+                    // TODO: warn about mismatch between columns
+                }
+
+                // the RetainOffsets column is handled in FinalizeFamilyFileRangesTable
+
+                if (null != row[7])
+                {
+                    externalFile.Order = Convert.ToInt32(row[7]);
+                }
+
+                Wix.Family family = (Wix.Family)this.core.GetIndexedElement("ImageFamilies", Convert.ToString(row[0]));
+                if (null != family)
+                {
+                    family.AddChild(externalFile);
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Family", Convert.ToString(row[0]), "ImageFamilies"));
+                }
+                this.core.IndexElement(row, externalFile);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the Feature table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileFeatureTable(Table table)
+        {
+            SortedList sortedFeatures = new SortedList();
+
+            foreach (Row row in table.Rows)
+            {
+                Wix.Feature feature = new Wix.Feature();
+
+                feature.Id = Convert.ToString(row[0]);
+
+                if (null != row[2])
+                {
+                    feature.Title = Convert.ToString(row[2]);
+                }
+
+                if (null != row[3])
+                {
+                    feature.Description = Convert.ToString(row[3]);
+                }
+
+                if (null == row[4])
+                {
+                    feature.Display = "hidden";
+                }
+                else
+                {
+                    int display = Convert.ToInt32(row[4]);
+
+                    if (0 == display)
+                    {
+                        feature.Display = "hidden";
+                    }
+                    else if (1 == display % 2)
+                    {
+                        feature.Display = "expand";
+                    }
+                }
+
+                feature.Level = Convert.ToInt32(row[5]);
+
+                if (null != row[6])
+                {
+                    feature.ConfigurableDirectory = Convert.ToString(row[6]);
+                }
+
+                int attributes = Convert.ToInt32(row[7]);
+
+                if (MsiInterop.MsidbFeatureAttributesFavorSource == (attributes & MsiInterop.MsidbFeatureAttributesFavorSource) && MsiInterop.MsidbFeatureAttributesFollowParent == (attributes & MsiInterop.MsidbFeatureAttributesFollowParent))
+                {
+                    // TODO: display a warning for setting favor local and follow parent together
+                }
+                else if (MsiInterop.MsidbFeatureAttributesFavorSource == (attributes & MsiInterop.MsidbFeatureAttributesFavorSource))
+                {
+                    feature.InstallDefault = Wix.Feature.InstallDefaultType.source;
+                }
+                else if (MsiInterop.MsidbFeatureAttributesFollowParent == (attributes & MsiInterop.MsidbFeatureAttributesFollowParent))
+                {
+                    feature.InstallDefault = Wix.Feature.InstallDefaultType.followParent;
+                }
+
+                if (MsiInterop.MsidbFeatureAttributesFavorAdvertise == (attributes & MsiInterop.MsidbFeatureAttributesFavorAdvertise))
+                {
+                    feature.TypicalDefault = Wix.Feature.TypicalDefaultType.advertise;
+                }
+
+                if (MsiInterop.MsidbFeatureAttributesDisallowAdvertise == (attributes & MsiInterop.MsidbFeatureAttributesDisallowAdvertise) &&
+                    MsiInterop.MsidbFeatureAttributesNoUnsupportedAdvertise == (attributes & MsiInterop.MsidbFeatureAttributesNoUnsupportedAdvertise))
+                {
+                    this.core.OnMessage(WixWarnings.InvalidAttributeCombination(row.SourceLineNumbers, "msidbFeatureAttributesDisallowAdvertise", "msidbFeatureAttributesNoUnsupportedAdvertise", "Feature.AllowAdvertiseType", "no"));
+                    feature.AllowAdvertise = Wix.Feature.AllowAdvertiseType.no;
+                }
+                else if (MsiInterop.MsidbFeatureAttributesDisallowAdvertise == (attributes & MsiInterop.MsidbFeatureAttributesDisallowAdvertise))
+                {
+                    feature.AllowAdvertise = Wix.Feature.AllowAdvertiseType.no;
+                }
+                else if (MsiInterop.MsidbFeatureAttributesNoUnsupportedAdvertise == (attributes & MsiInterop.MsidbFeatureAttributesNoUnsupportedAdvertise))
+                {
+                    feature.AllowAdvertise = Wix.Feature.AllowAdvertiseType.system;
+                }
+
+                if (MsiInterop.MsidbFeatureAttributesUIDisallowAbsent == (attributes & MsiInterop.MsidbFeatureAttributesUIDisallowAbsent))
+                {
+                    feature.Absent = Wix.Feature.AbsentType.disallow;
+                }
+
+                this.core.IndexElement(row, feature);
+
+                // sort the features by their display column (and append the identifier to ensure unique keys)
+                sortedFeatures.Add(String.Format(CultureInfo.InvariantCulture, "{0:00000}|{1}", Convert.ToInt32(row[4], CultureInfo.InvariantCulture), row[0]), row);
+            }
+
+            // nest the features
+            foreach (Row row in sortedFeatures.Values)
+            {
+                Wix.Feature feature = (Wix.Feature)this.core.GetIndexedElement("Feature", Convert.ToString(row[0]));
+
+                if (null == row[1])
+                {
+                    this.core.RootElement.AddChild(feature);
+                }
+                else
+                {
+                    Wix.Feature parentFeature = (Wix.Feature)this.core.GetIndexedElement("Feature", Convert.ToString(row[1]));
+
+                    if (null == parentFeature)
+                    {
+                        this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Feature_Parent", Convert.ToString(row[1]), "Feature"));
+                    }
+                    else if (parentFeature == feature)
+                    {
+                        // TODO: display a warning about self-nesting
+                    }
+                    else
+                    {
+                        parentFeature.AddChild(feature);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the FeatureComponents table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileFeatureComponentsTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.ComponentRef componentRef = new Wix.ComponentRef();
+
+                componentRef.Id = Convert.ToString(row[1]);
+
+                Wix.Feature parentFeature = (Wix.Feature)this.core.GetIndexedElement("Feature", Convert.ToString(row[0]));
+                if (null != parentFeature)
+                {
+                    parentFeature.AddChild(componentRef);
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Feature_", Convert.ToString(row[0]), "Feature"));
+                }
+                this.core.IndexElement(row, componentRef);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the File table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileFileTable(Table table)
+        {
+            foreach (FileRow fileRow in table.Rows)
+            {
+                Wix.File file = new Wix.File();
+
+                file.Id = fileRow.File;
+
+                string[] names = Installer.GetNames(fileRow.FileName);
+                if (null != names[0] && null != names[1])
+                {
+                    file.ShortName = names[0];
+                    file.Name = names[1];
+                }
+                else if (null != names[0])
+                {
+                    file.Name = names[0];
+                }
+
+                if (null != fileRow.Version && 0 < fileRow.Version.Length)
+                {
+                    if (!Char.IsDigit(fileRow.Version[0]))
+                    {
+                        file.CompanionFile = fileRow.Version;
+                    }
+                }
+
+                if (MsiInterop.MsidbFileAttributesReadOnly == (fileRow.Attributes & MsiInterop.MsidbFileAttributesReadOnly))
+                {
+                    file.ReadOnly = Wix.YesNoType.yes;
+                }
+
+                if (MsiInterop.MsidbFileAttributesHidden == (fileRow.Attributes & MsiInterop.MsidbFileAttributesHidden))
+                {
+                    file.Hidden = Wix.YesNoType.yes;
+                }
+
+                if (MsiInterop.MsidbFileAttributesSystem == (fileRow.Attributes & MsiInterop.MsidbFileAttributesSystem))
+                {
+                    file.System = Wix.YesNoType.yes;
+                }
+
+                if (MsiInterop.MsidbFileAttributesVital != (fileRow.Attributes & MsiInterop.MsidbFileAttributesVital))
+                {
+                    file.Vital = Wix.YesNoType.no;
+                }
+
+                if (MsiInterop.MsidbFileAttributesChecksum == (fileRow.Attributes & MsiInterop.MsidbFileAttributesChecksum))
+                {
+                    file.Checksum = Wix.YesNoType.yes;
+                }
+
+                if (MsiInterop.MsidbFileAttributesNoncompressed == (fileRow.Attributes & MsiInterop.MsidbFileAttributesNoncompressed) &&
+                    MsiInterop.MsidbFileAttributesCompressed == (fileRow.Attributes & MsiInterop.MsidbFileAttributesCompressed))
+                {
+                    // TODO: error
+                }
+                else if (MsiInterop.MsidbFileAttributesNoncompressed == (fileRow.Attributes & MsiInterop.MsidbFileAttributesNoncompressed))
+                {
+                    file.Compressed = Wix.YesNoDefaultType.no;
+                }
+                else if (MsiInterop.MsidbFileAttributesCompressed == (fileRow.Attributes & MsiInterop.MsidbFileAttributesCompressed))
+                {
+                    file.Compressed = Wix.YesNoDefaultType.yes;
+                }
+
+                this.core.IndexElement(fileRow, file);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the FileSFPCatalog table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileFileSFPCatalogTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.SFPFile sfpFile = new Wix.SFPFile();
+
+                sfpFile.Id = Convert.ToString(row[0]);
+
+                Wix.SFPCatalog sfpCatalog = (Wix.SFPCatalog)this.core.GetIndexedElement("SFPCatalog", Convert.ToString(row[1]));
+                if (null != sfpCatalog)
+                {
+                    sfpCatalog.AddChild(sfpFile);
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "SFPCatalog_", Convert.ToString(row[1]), "SFPCatalog"));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the Font table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileFontTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.File file = (Wix.File)this.core.GetIndexedElement("File", Convert.ToString(row[0]));
+
+                if (null != file)
+                {
+                    if (null != row[1])
+                    {
+                        file.FontTitle = Convert.ToString(row[1]);
+                    }
+                    else
+                    {
+                        file.TrueType = Wix.YesNoType.yes;
+                    }
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "File_", Convert.ToString(row[0]), "File"));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the Icon table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileIconTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.Icon icon = new Wix.Icon();
+
+                icon.Id = Convert.ToString(row[0]);
+
+                icon.SourceFile = Convert.ToString(row[1]);
+
+                this.core.RootElement.AddChild(icon);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the ImageFamilies table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileImageFamiliesTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.Family family = new Wix.Family();
+
+                family.Name = Convert.ToString(row[0]);
+
+                if (null != row[1])
+                {
+                    family.MediaSrcProp = Convert.ToString(row[1]);
+                }
+
+                if (null != row[2])
+                {
+                    family.DiskId = Convert.ToString(Convert.ToInt32(row[2]));
+                }
+
+                if (null != row[3])
+                {
+                    family.SequenceStart = Convert.ToInt32(row[3]);
+                }
+
+                if (null != row[4])
+                {
+                    family.DiskPrompt = Convert.ToString(row[4]);
+                }
+
+                if (null != row[5])
+                {
+                    family.VolumeLabel = Convert.ToString(row[5]);
+                }
+
+                this.core.RootElement.AddChild(family);
+                this.core.IndexElement(row, family);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the IniFile table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileIniFileTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.IniFile iniFile = new Wix.IniFile();
+
+                iniFile.Id = Convert.ToString(row[0]);
+
+                string[] names = Installer.GetNames(Convert.ToString(row[1]));
+
+                if (null != names[0])
+                {
+                    if (null == names[1])
+                    {
+                        iniFile.Name = names[0];
+                    }
+                    else
+                    {
+                        iniFile.ShortName = names[0];
+                    }
+                }
+
+                if (null != names[1])
+                {
+                    iniFile.Name = names[1];
+                }
+
+                if (null != row[2])
+                {
+                    iniFile.Directory = Convert.ToString(row[2]);
+                }
+
+                iniFile.Section = Convert.ToString(row[3]);
+
+                iniFile.Key = Convert.ToString(row[4]);
+
+                iniFile.Value = Convert.ToString(row[5]);
+
+                switch (Convert.ToInt32(row[6]))
+                {
+                    case MsiInterop.MsidbIniFileActionAddLine:
+                        iniFile.Action = Wix.IniFile.ActionType.addLine;
+                        break;
+                    case MsiInterop.MsidbIniFileActionCreateLine:
+                        iniFile.Action = Wix.IniFile.ActionType.createLine;
+                        break;
+                    case MsiInterop.MsidbIniFileActionAddTag:
+                        iniFile.Action = Wix.IniFile.ActionType.addTag;
+                        break;
+                    default:
+                        this.core.OnMessage(WixWarnings.IllegalColumnValue(row.SourceLineNumbers, table.Name, row.Fields[6].Column.Name, row[6]));
+                        break;
+                }
+
+                Wix.Component component = (Wix.Component)this.core.GetIndexedElement("Component", Convert.ToString(row[7]));
+                if (null != component)
+                {
+                    component.AddChild(iniFile);
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", Convert.ToString(row[7]), "Component"));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the IniLocator table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileIniLocatorTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.IniFileSearch iniFileSearch = new Wix.IniFileSearch();
+
+                iniFileSearch.Id = Convert.ToString(row[0]);
+
+                string[] names = Installer.GetNames(Convert.ToString(row[1]));
+                if (null != names[0] && null != names[1])
+                {
+                    iniFileSearch.ShortName = names[0];
+                    iniFileSearch.Name = names[1];
+                }
+                else if (null != names[0])
+                {
+                    iniFileSearch.Name = names[0];
+                }
+
+                iniFileSearch.Section = Convert.ToString(row[2]);
+
+                iniFileSearch.Key = Convert.ToString(row[3]);
+
+                if (null != row[4])
+                {
+                    int field = Convert.ToInt32(row[4]);
+
+                    if (0 != field)
+                    {
+                        iniFileSearch.Field = field;
+                    }
+                }
+
+                if (null != row[5])
+                {
+                    switch (Convert.ToInt32(row[5]))
+                    {
+                        case MsiInterop.MsidbLocatorTypeDirectory:
+                            iniFileSearch.Type = Wix.IniFileSearch.TypeType.directory;
+                            break;
+                        case MsiInterop.MsidbLocatorTypeFileName:
+                            // this is the default value
+                            break;
+                        case MsiInterop.MsidbLocatorTypeRawValue:
+                            iniFileSearch.Type = Wix.IniFileSearch.TypeType.raw;
+                            break;
+                        default:
+                            this.core.OnMessage(WixWarnings.IllegalColumnValue(row.SourceLineNumbers, table.Name, row.Fields[5].Column.Name, row[5]));
+                            break;
+                    }
+                }
+
+                this.core.IndexElement(row, iniFileSearch);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the IsolatedComponent table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileIsolatedComponentTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.IsolateComponent isolateComponent = new Wix.IsolateComponent();
+
+                isolateComponent.Shared = Convert.ToString(row[0]);
+
+                Wix.Component component = (Wix.Component)this.core.GetIndexedElement("Component", Convert.ToString(row[1]));
+                if (null != component)
+                {
+                    component.AddChild(isolateComponent);
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", Convert.ToString(row[1]), "Component"));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the LaunchCondition table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileLaunchConditionTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                if (Compiler.DowngradePreventedCondition == Convert.ToString(row[0]) || Compiler.UpgradePreventedCondition == Convert.ToString(row[0]))
+                {
+                    continue; // MajorUpgrade rows processed in FinalizeUpgradeTable
+                }
+
+                Wix.Condition condition = new Wix.Condition();
+
+                condition.Content = Convert.ToString(row[0]);
+
+                condition.Message = Convert.ToString(row[1]);
+
+                this.core.RootElement.AddChild(condition);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the ListBox table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileListBoxTable(Table table)
+        {
+            Wix.ListBox listBox = null;
+            SortedList listBoxRows = new SortedList();
+
+            // sort the list boxes by their property and order
+            foreach (Row row in table.Rows)
+            {
+                listBoxRows.Add(String.Concat("{0}|{1:0000000000}", row[0], row[1]), row);
+            }
+
+            foreach (Row row in listBoxRows.Values)
+            {
+                if (null == listBox || Convert.ToString(row[0]) != listBox.Property)
+                {
+                    listBox = new Wix.ListBox();
+
+                    listBox.Property = Convert.ToString(row[0]);
+
+                    this.core.UIElement.AddChild(listBox);
+                }
+
+                Wix.ListItem listItem = new Wix.ListItem();
+
+                listItem.Value = Convert.ToString(row[2]);
+
+                if (null != row[3])
+                {
+                    listItem.Text = Convert.ToString(row[3]);
+                }
+
+                listBox.AddChild(listItem);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the ListView table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileListViewTable(Table table)
+        {
+            Wix.ListView listView = null;
+            SortedList listViewRows = new SortedList();
+
+            // sort the list views by their property and order
+            foreach (Row row in table.Rows)
+            {
+                listViewRows.Add(String.Concat("{0}|{1:0000000000}", row[0], row[1]), row);
+            }
+
+            foreach (Row row in listViewRows.Values)
+            {
+                if (null == listView || Convert.ToString(row[0]) != listView.Property)
+                {
+                    listView = new Wix.ListView();
+
+                    listView.Property = Convert.ToString(row[0]);
+
+                    this.core.UIElement.AddChild(listView);
+                }
+
+                Wix.ListItem listItem = new Wix.ListItem();
+
+                listItem.Value = Convert.ToString(row[2]);
+
+                if (null != row[3])
+                {
+                    listItem.Text = Convert.ToString(row[3]);
+                }
+
+                if (null != row[4])
+                {
+                    listItem.Icon = Convert.ToString(row[4]);
+                }
+
+                listView.AddChild(listItem);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the LockPermissions table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileLockPermissionsTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.Permission permission = new Wix.Permission();
+                string[] specialPermissions;
+
+                switch (Convert.ToString(row[1]))
+                {
+                    case "CreateFolder":
+                        specialPermissions = Common.FolderPermissions;
+                        break;
+                    case "File":
+                        specialPermissions = Common.FilePermissions;
+                        break;
+                    case "Registry":
+                        specialPermissions = Common.RegistryPermissions;
+                        break;
+                    default:
+                        this.core.OnMessage(WixWarnings.IllegalColumnValue(row.SourceLineNumbers, row.Table.Name, row.Fields[1].Column.Name, row[1]));
+                        return;
+                }
+
+                int permissionBits = Convert.ToInt32(row[4]);
+                for (int i = 0; i < 32; i++)
+                {
+                    if (0 != ((permissionBits >> i) & 1))
+                    {
+                        string name = null;
+
+                        if (specialPermissions.Length > i)
+                        {
+                            name = specialPermissions[i];
+                        }
+                        else if (16 > i && specialPermissions.Length <= i)
+                        {
+                            name = "SpecificRightsAll";
+                        }
+                        else if (28 > i && Common.StandardPermissions.Length > (i - 16))
+                        {
+                            name = Common.StandardPermissions[i - 16];
+                        }
+                        else if (0 <= (i - 28) && Common.GenericPermissions.Length > (i - 28))
+                        {
+                            name = Common.GenericPermissions[i - 28];
+                        }
+
+                        if (null == name)
+                        {
+                            this.core.OnMessage(WixWarnings.UnknownPermission(row.SourceLineNumbers, row.Table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), i));
+                        }
+                        else
+                        {
+                            switch (name)
+                            {
+                                case "Append":
+                                    permission.Append = Wix.YesNoType.yes;
+                                    break;
+                                case "ChangePermission":
+                                    permission.ChangePermission = Wix.YesNoType.yes;
+                                    break;
+                                case "CreateChild":
+                                    permission.CreateChild = Wix.YesNoType.yes;
+                                    break;
+                                case "CreateFile":
+                                    permission.CreateFile = Wix.YesNoType.yes;
+                                    break;
+                                case "CreateLink":
+                                    permission.CreateLink = Wix.YesNoType.yes;
+                                    break;
+                                case "CreateSubkeys":
+                                    permission.CreateSubkeys = Wix.YesNoType.yes;
+                                    break;
+                                case "Delete":
+                                    permission.Delete = Wix.YesNoType.yes;
+                                    break;
+                                case "DeleteChild":
+                                    permission.DeleteChild = Wix.YesNoType.yes;
+                                    break;
+                                case "EnumerateSubkeys":
+                                    permission.EnumerateSubkeys = Wix.YesNoType.yes;
+                                    break;
+                                case "Execute":
+                                    permission.Execute = Wix.YesNoType.yes;
+                                    break;
+                                case "FileAllRights":
+                                    permission.FileAllRights = Wix.YesNoType.yes;
+                                    break;
+                                case "GenericAll":
+                                    permission.GenericAll = Wix.YesNoType.yes;
+                                    break;
+                                case "GenericExecute":
+                                    permission.GenericExecute = Wix.YesNoType.yes;
+                                    break;
+                                case "GenericRead":
+                                    permission.GenericRead = Wix.YesNoType.yes;
+                                    break;
+                                case "GenericWrite":
+                                    permission.GenericWrite = Wix.YesNoType.yes;
+                                    break;
+                                case "Notify":
+                                    permission.Notify = Wix.YesNoType.yes;
+                                    break;
+                                case "Read":
+                                    permission.Read = Wix.YesNoType.yes;
+                                    break;
+                                case "ReadAttributes":
+                                    permission.ReadAttributes = Wix.YesNoType.yes;
+                                    break;
+                                case "ReadExtendedAttributes":
+                                    permission.ReadExtendedAttributes = Wix.YesNoType.yes;
+                                    break;
+                                case "ReadPermission":
+                                    permission.ReadPermission = Wix.YesNoType.yes;
+                                    break;
+                                case "SpecificRightsAll":
+                                    permission.SpecificRightsAll = Wix.YesNoType.yes;
+                                    break;
+                                case "Synchronize":
+                                    permission.Synchronize = Wix.YesNoType.yes;
+                                    break;
+                                case "TakeOwnership":
+                                    permission.TakeOwnership = Wix.YesNoType.yes;
+                                    break;
+                                case "Traverse":
+                                    permission.Traverse = Wix.YesNoType.yes;
+                                    break;
+                                case "Write":
+                                    permission.Write = Wix.YesNoType.yes;
+                                    break;
+                                case "WriteAttributes":
+                                    permission.WriteAttributes = Wix.YesNoType.yes;
+                                    break;
+                                case "WriteExtendedAttributes":
+                                    permission.WriteExtendedAttributes = Wix.YesNoType.yes;
+                                    break;
+                                default:
+                                    throw new InvalidOperationException(String.Format(CultureInfo.CurrentUICulture, WixStrings.EXP_UnknownPermissionAttribute, name));
+                            }
+                        }
+                    }
+                }
+
+                if (null != row[2])
+                {
+                    permission.Domain = Convert.ToString(row[2]);
+                }
+
+                permission.User = Convert.ToString(row[3]);
+
+                this.core.IndexElement(row, permission);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the Media table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileMediaTable(Table table)
+        {
+            foreach (MediaRow mediaRow in table.Rows)
+            {
+                Wix.Media media = new Wix.Media();
+
+                media.Id = Convert.ToString(mediaRow.DiskId);
+
+                if (null != mediaRow.DiskPrompt)
+                {
+                    media.DiskPrompt = mediaRow.DiskPrompt;
+                }
+
+                if (null != mediaRow.Cabinet)
+                {
+                    string cabinet = mediaRow.Cabinet;
+
+                    if (cabinet.StartsWith("#", StringComparison.Ordinal))
+                    {
+                        media.EmbedCab = Wix.YesNoType.yes;
+                        cabinet = cabinet.Substring(1);
+                    }
+
+                    media.Cabinet = cabinet;
+                }
+
+                if (null != mediaRow.VolumeLabel)
+                {
+                    media.VolumeLabel = mediaRow.VolumeLabel;
+                }
+
+                this.core.RootElement.AddChild(media);
+                this.core.IndexElement(mediaRow, media);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the MIME table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileMIMETable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.MIME mime = new Wix.MIME();
+
+                mime.ContentType = Convert.ToString(row[0]);
+
+                if (null != row[2])
+                {
+                    mime.Class = Convert.ToString(row[2]);
+                }
+
+                this.core.IndexElement(row, mime);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the ModuleConfiguration table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileModuleConfigurationTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.Configuration configuration = new Wix.Configuration();
+
+                configuration.Name = Convert.ToString(row[0]);
+
+                switch (Convert.ToInt32(row[1]))
+                {
+                    case 0:
+                        configuration.Format = Wix.Configuration.FormatType.Text;
+                        break;
+                    case 1:
+                        configuration.Format = Wix.Configuration.FormatType.Key;
+                        break;
+                    case 2:
+                        configuration.Format = Wix.Configuration.FormatType.Integer;
+                        break;
+                    case 3:
+                        configuration.Format = Wix.Configuration.FormatType.Bitfield;
+                        break;
+                    default:
+                        this.core.OnMessage(WixWarnings.IllegalColumnValue(row.SourceLineNumbers, table.Name, row.Fields[1].Column.Name, row[1]));
+                        break;
+                }
+
+                if (null != row[2])
+                {
+                    configuration.Type = Convert.ToString(row[2]);
+                }
+
+                if (null != row[3])
+                {
+                    configuration.ContextData = Convert.ToString(row[3]);
+                }
+
+                if (null != row[4])
+                {
+                    configuration.DefaultValue = Convert.ToString(row[4]);
+                }
+
+                if (null != row[5])
+                {
+                    int attributes = Convert.ToInt32(row[5]);
+
+                    if (MsiInterop.MsidbMsmConfigurableOptionKeyNoOrphan == (attributes & MsiInterop.MsidbMsmConfigurableOptionKeyNoOrphan))
+                    {
+                        configuration.KeyNoOrphan = Wix.YesNoType.yes;
+                    }
+
+                    if (MsiInterop.MsidbMsmConfigurableOptionNonNullable == (attributes & MsiInterop.MsidbMsmConfigurableOptionNonNullable))
+                    {
+                        configuration.NonNullable = Wix.YesNoType.yes;
+                    }
+
+                    if (3 < attributes)
+                    {
+                        this.core.OnMessage(WixWarnings.IllegalColumnValue(row.SourceLineNumbers, table.Name, row.Fields[5].Column.Name, row[5]));
+                    }
+                }
+
+                if (null != row[6])
+                {
+                    configuration.DisplayName = Convert.ToString(row[6]);
+                }
+
+                if (null != row[7])
+                {
+                    configuration.Description = Convert.ToString(row[7]);
+                }
+
+                if (null != row[8])
+                {
+                    configuration.HelpLocation = Convert.ToString(row[8]);
+                }
+
+                if (null != row[9])
+                {
+                    configuration.HelpKeyword = Convert.ToString(row[9]);
+                }
+
+                this.core.RootElement.AddChild(configuration);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the ModuleDependency table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileModuleDependencyTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.Dependency dependency = new Wix.Dependency();
+
+                dependency.RequiredId = Convert.ToString(row[2]);
+
+                dependency.RequiredLanguage = Convert.ToInt32(row[3], CultureInfo.InvariantCulture);
+
+                if (null != row[4])
+                {
+                    dependency.RequiredVersion = Convert.ToString(row[4]);
+                }
+
+                this.core.RootElement.AddChild(dependency);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the ModuleExclusion table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileModuleExclusionTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.Exclusion exclusion = new Wix.Exclusion();
+
+                exclusion.ExcludedId = Convert.ToString(row[2]);
+
+                int excludedLanguage = Convert.ToInt32(Convert.ToString(row[3]), CultureInfo.InvariantCulture);
+                if (0 < excludedLanguage)
+                {
+                    exclusion.ExcludeLanguage = excludedLanguage;
+                }
+                else if (0 > excludedLanguage)
+                {
+                    exclusion.ExcludeExceptLanguage = -excludedLanguage;
+                }
+
+                if (null != row[4])
+                {
+                    exclusion.ExcludedMinVersion = Convert.ToString(row[4]);
+                }
+
+                if (null != row[5])
+                {
+                    exclusion.ExcludedMinVersion = Convert.ToString(row[5]);
+                }
+
+                this.core.RootElement.AddChild(exclusion);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the ModuleIgnoreTable table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileModuleIgnoreTableTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                string tableName = Convert.ToString(row[0]);
+
+                // the linker automatically adds a ModuleIgnoreTable row for some tables
+                if ("ModuleConfiguration" != tableName && "ModuleSubstitution" != tableName)
+                {
+                    Wix.IgnoreTable ignoreTable = new Wix.IgnoreTable();
+
+                    ignoreTable.Id = tableName;
+
+                    this.core.RootElement.AddChild(ignoreTable);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the ModuleSignature table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileModuleSignatureTable(Table table)
+        {
+            if (1 == table.Rows.Count)
+            {
+                Row row = table.Rows[0];
+
+                Wix.Module module = (Wix.Module)this.core.RootElement;
+
+                module.Id = Convert.ToString(row[0]);
+
+                // support Language columns that are treated as integers as well as strings (the WiX default, to support localizability)
+                module.Language = Convert.ToString(row[1], CultureInfo.InvariantCulture);
+
+                module.Version = Convert.ToString(row[2]);
+            }
+            else
+            {
+                // TODO: warn
+            }
+        }
+
+        /// <summary>
+        /// Decompile the ModuleSubstitution table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileModuleSubstitutionTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.Substitution substitution = new Wix.Substitution();
+
+                substitution.Table = Convert.ToString(row[0]);
+
+                substitution.Row = Convert.ToString(row[1]);
+
+                substitution.Column = Convert.ToString(row[2]);
+
+                if (null != row[3])
+                {
+                    substitution.Value = Convert.ToString(row[3]);
+                }
+
+                this.core.RootElement.AddChild(substitution);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the MoveFile table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileMoveFileTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.CopyFile copyFile = new Wix.CopyFile();
+
+                copyFile.Id = Convert.ToString(row[0]);
+
+                if (null != row[2])
+                {
+                    copyFile.SourceName = Convert.ToString(row[2]);
+                }
+
+                if (null != row[3])
+                {
+                    string[] names = Installer.GetNames(Convert.ToString(row[3]));
+                    if (null != names[0] && null != names[1])
+                    {
+                        copyFile.DestinationShortName = names[0];
+                        copyFile.DestinationName = names[1];
+                    }
+                    else if (null != names[0])
+                    {
+                        copyFile.DestinationName = names[0];
+                    }
+                }
+
+                // source/destination directory/property is set in FinalizeDuplicateMoveFileTables
+
+                switch (Convert.ToInt32(row[6]))
+                {
+                    case 0:
+                        break;
+                    case MsiInterop.MsidbMoveFileOptionsMove:
+                        copyFile.Delete = Wix.YesNoType.yes;
+                        break;
+                    default:
+                        this.core.OnMessage(WixWarnings.IllegalColumnValue(row.SourceLineNumbers, table.Name, row.Fields[6].Column.Name, row[6]));
+                        break;
+                }
+
+                Wix.Component component = (Wix.Component)this.core.GetIndexedElement("Component", Convert.ToString(row[1]));
+                if (null != component)
+                {
+                    component.AddChild(copyFile);
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", Convert.ToString(row[1]), "Component"));
+                }
+                this.core.IndexElement(row, copyFile);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the MsiDigitalCertificate table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileMsiDigitalCertificateTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.DigitalCertificate digitalCertificate = new Wix.DigitalCertificate();
+
+                digitalCertificate.Id = Convert.ToString(row[0]);
+
+                digitalCertificate.SourceFile = Convert.ToString(row[1]);
+
+                this.core.IndexElement(row, digitalCertificate);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the MsiDigitalSignature table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileMsiDigitalSignatureTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.DigitalSignature digitalSignature = new Wix.DigitalSignature();
+
+                if (null != row[3])
+                {
+                    digitalSignature.SourceFile = Convert.ToString(row[3]);
+                }
+
+                Wix.DigitalCertificate digitalCertificate = (Wix.DigitalCertificate)this.core.GetIndexedElement("MsiDigitalCertificate", Convert.ToString(row[2]));
+                if (null != digitalCertificate)
+                {
+                    digitalSignature.AddChild(digitalCertificate);
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "DigitalCertificate_", Convert.ToString(row[2]), "MsiDigitalCertificate"));
+                }
+
+                Wix.IParentElement parentElement = (Wix.IParentElement)this.core.GetIndexedElement(Convert.ToString(row[0]), Convert.ToString(row[1]));
+                if (null != parentElement)
+                {
+                    parentElement.AddChild(digitalSignature);
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "SignObject", Convert.ToString(row[1]), Convert.ToString(row[0])));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the MsiEmbeddedChainer table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileMsiEmbeddedChainerTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.EmbeddedChainer embeddedChainer = new Wix.EmbeddedChainer();
+
+                embeddedChainer.Id = Convert.ToString(row[0]);
+
+                embeddedChainer.Content = Convert.ToString(row[1]);
+
+                if (null != row[2])
+                {
+                    embeddedChainer.CommandLine = Convert.ToString(row[2]);
+                }
+
+                switch (Convert.ToInt32(row[4]))
+                {
+                    case MsiInterop.MsidbCustomActionTypeExe + MsiInterop.MsidbCustomActionTypeBinaryData:
+                        embeddedChainer.BinarySource = Convert.ToString(row[3]);
+                        break;
+                    case MsiInterop.MsidbCustomActionTypeExe + MsiInterop.MsidbCustomActionTypeSourceFile:
+                        embeddedChainer.FileSource = Convert.ToString(row[3]);
+                        break;
+                    case MsiInterop.MsidbCustomActionTypeExe + MsiInterop.MsidbCustomActionTypeProperty:
+                        embeddedChainer.PropertySource = Convert.ToString(row[3]);
+                        break;
+                    default:
+                        this.core.OnMessage(WixWarnings.IllegalColumnValue(row.SourceLineNumbers, table.Name, row.Fields[4].Column.Name, row[4]));
+                        break;
+                }
+
+                this.core.RootElement.AddChild(embeddedChainer);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the MsiEmbeddedUI table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileMsiEmbeddedUITable(Table table)
+        {
+            Wix.EmbeddedUI embeddedUI = new Wix.EmbeddedUI();
+            bool foundEmbeddedUI = false;
+            bool foundEmbeddedResources = false;
+
+            foreach (Row row in table.Rows)
+            {
+                int attributes = Convert.ToInt32(row[2]);
+
+                if (MsiInterop.MsidbEmbeddedUI == (attributes & MsiInterop.MsidbEmbeddedUI))
+                {
+                    if (foundEmbeddedUI)
+                    {
+                        this.core.OnMessage(WixWarnings.IllegalColumnValue(row.SourceLineNumbers, table.Name, row.Fields[2].Column.Name, row[2]));
+                    }
+                    else
+                    {
+                        embeddedUI.Id = Convert.ToString(row[0]);
+                        embeddedUI.Name = Convert.ToString(row[1]);
+
+                        int messageFilter = Convert.ToInt32(row[3]);
+                        if (0 == (messageFilter & MsiInterop.INSTALLLOGMODE_FATALEXIT))
+                        {
+                            embeddedUI.IgnoreFatalExit = Wix.YesNoType.yes;
+                        }
+
+                        if (0 == (messageFilter & MsiInterop.INSTALLLOGMODE_ERROR))
+                        {
+                            embeddedUI.IgnoreError = Wix.YesNoType.yes;
+                        }
+
+                        if (0 == (messageFilter & MsiInterop.INSTALLLOGMODE_WARNING))
+                        {
+                            embeddedUI.IgnoreWarning = Wix.YesNoType.yes;
+                        }
+
+                        if (0 == (messageFilter & MsiInterop.INSTALLLOGMODE_USER))
+                        {
+                            embeddedUI.IgnoreUser = Wix.YesNoType.yes;
+                        }
+
+                        if (0 == (messageFilter & MsiInterop.INSTALLLOGMODE_INFO))
+                        {
+                            embeddedUI.IgnoreInfo = Wix.YesNoType.yes;
+                        }
+
+                        if (0 == (messageFilter & MsiInterop.INSTALLLOGMODE_FILESINUSE))
+                        {
+                            embeddedUI.IgnoreFilesInUse = Wix.YesNoType.yes;
+                        }
+
+                        if (0 == (messageFilter & MsiInterop.INSTALLLOGMODE_RESOLVESOURCE))
+                        {
+                            embeddedUI.IgnoreResolveSource = Wix.YesNoType.yes;
+                        }
+
+                        if (0 == (messageFilter & MsiInterop.INSTALLLOGMODE_OUTOFDISKSPACE))
+                        {
+                            embeddedUI.IgnoreOutOfDiskSpace = Wix.YesNoType.yes;
+                        }
+
+                        if (0 == (messageFilter & MsiInterop.INSTALLLOGMODE_ACTIONSTART))
+                        {
+                            embeddedUI.IgnoreActionStart = Wix.YesNoType.yes;
+                        }
+
+                        if (0 == (messageFilter & MsiInterop.INSTALLLOGMODE_ACTIONDATA))
+                        {
+                            embeddedUI.IgnoreActionData = Wix.YesNoType.yes;
+                        }
+
+                        if (0 == (messageFilter & MsiInterop.INSTALLLOGMODE_PROGRESS))
+                        {
+                            embeddedUI.IgnoreProgress = Wix.YesNoType.yes;
+                        }
+
+                        if (0 == (messageFilter & MsiInterop.INSTALLLOGMODE_COMMONDATA))
+                        {
+                            embeddedUI.IgnoreCommonData = Wix.YesNoType.yes;
+                        }
+
+                        if (0 == (messageFilter & MsiInterop.INSTALLLOGMODE_INITIALIZE))
+                        {
+                            embeddedUI.IgnoreInitialize = Wix.YesNoType.yes;
+                        }
+
+                        if (0 == (messageFilter & MsiInterop.INSTALLLOGMODE_TERMINATE))
+                        {
+                            embeddedUI.IgnoreTerminate = Wix.YesNoType.yes;
+                        }
+
+                        if (0 == (messageFilter & MsiInterop.INSTALLLOGMODE_SHOWDIALOG))
+                        {
+                            embeddedUI.IgnoreShowDialog = Wix.YesNoType.yes;
+                        }
+
+                        if (0 == (messageFilter & MsiInterop.INSTALLLOGMODE_RMFILESINUSE))
+                        {
+                            embeddedUI.IgnoreRMFilesInUse = Wix.YesNoType.yes;
+                        }
+
+                        if (0 == (messageFilter & MsiInterop.INSTALLLOGMODE_INSTALLSTART))
+                        {
+                            embeddedUI.IgnoreInstallStart = Wix.YesNoType.yes;
+                        }
+
+                        if (0 == (messageFilter & MsiInterop.INSTALLLOGMODE_INSTALLEND))
+                        {
+                            embeddedUI.IgnoreInstallEnd = Wix.YesNoType.yes;
+                        }
+
+                        if (MsiInterop.MsidbEmbeddedHandlesBasic == (attributes & MsiInterop.MsidbEmbeddedHandlesBasic))
+                        {
+                            embeddedUI.SupportBasicUI = Wix.YesNoType.yes;
+                        }
+
+                        embeddedUI.SourceFile = Convert.ToString(row[4]);
+
+                        this.core.UIElement.AddChild(embeddedUI);
+                        foundEmbeddedUI = true;
+                    }
+                }
+                else
+                {
+                    Wix.EmbeddedUIResource embeddedResource = new Wix.EmbeddedUIResource();
+
+                    embeddedResource.Id = Convert.ToString(row[0]);
+                    embeddedResource.Name = Convert.ToString(row[1]);
+                    embeddedResource.SourceFile = Convert.ToString(row[4]);
+
+                    embeddedUI.AddChild(embeddedResource);
+                    foundEmbeddedResources = true;
+                }
+            }
+
+            if (!foundEmbeddedUI && foundEmbeddedResources)
+            {
+                // TODO: warn
+            }
+        }
+
+        /// <summary>
+        /// Decompile the MsiLockPermissionsEx table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileMsiLockPermissionsExTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.PermissionEx permissionEx = new Wix.PermissionEx();
+                permissionEx.Id = Convert.ToString(row[0]);
+                permissionEx.Sddl = Convert.ToString(row[3]);
+
+                if (null != row[4])
+                {
+                    Wix.Condition condition = new Wix.Condition();
+                    condition.Content = Convert.ToString(row[4]);
+                    permissionEx.AddChild(condition);
+                }
+
+                switch (Convert.ToString(row[2]))
+                {
+                    case "CreateFolder":
+                    case "File":
+                    case "Registry":
+                    case "ServiceInstall":
+                        break;
+                    default:
+                        this.core.OnMessage(WixWarnings.IllegalColumnValue(row.SourceLineNumbers, row.Table.Name, row.Fields[1].Column.Name, row[1]));
+                        return;
+                }
+
+                this.core.IndexElement(row, permissionEx);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the MsiPackageCertificate table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileMsiPackageCertificateTable(Table table)
+        {
+            if (0 < table.Rows.Count)
+            {
+                Wix.PackageCertificates packageCertificates = new Wix.PackageCertificates();
+                this.core.RootElement.AddChild(packageCertificates);
+                AddCertificates(table, packageCertificates);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the MsiPatchCertificate table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileMsiPatchCertificateTable(Table table)
+        {
+            if (0 < table.Rows.Count)
+            {
+                Wix.PatchCertificates patchCertificates = new Wix.PatchCertificates();
+                this.core.RootElement.AddChild(patchCertificates);
+                AddCertificates(table, patchCertificates);
+            }
+        }
+
+        /// <summary>
+        /// Insert DigitalCertificate records associated with passed msiPackageCertificate or msiPatchCertificate table.
+        /// </summary>
+        /// <param name="table">The table being decompiled.</param>
+        /// <param name="parent">DigitalCertificate parent</param>
+        private void AddCertificates(Table table, Wix.IParentElement parent)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.DigitalCertificate digitalCertificate = (Wix.DigitalCertificate)this.core.GetIndexedElement("MsiDigitalCertificate", Convert.ToString(row[1]));
+
+                if (null != digitalCertificate)
+                {
+                    parent.AddChild(digitalCertificate);
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "DigitalCertificate_", Convert.ToString(row[1]), "MsiDigitalCertificate"));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the MsiShortcutProperty table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileMsiShortcutPropertyTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.ShortcutProperty property = new Wix.ShortcutProperty();
+                property.Id = Convert.ToString(row[0]);
+                property.Key = Convert.ToString(row[2]);
+                property.Value = Convert.ToString(row[3]);
+
+                Wix.Shortcut shortcut = (Wix.Shortcut)this.core.GetIndexedElement("Shortcut", Convert.ToString(row[1]));
+                if (null != shortcut)
+                {
+                    shortcut.AddChild(property);
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Shortcut_", Convert.ToString(row[1]), "Shortcut"));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the ODBCAttribute table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileODBCAttributeTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.Property property = new Wix.Property();
+
+                property.Id = Convert.ToString(row[1]);
+
+                if (null != row[2])
+                {
+                    property.Value = Convert.ToString(row[2]);
+                }
+
+                Wix.ODBCDriver odbcDriver = (Wix.ODBCDriver)this.core.GetIndexedElement("ODBCDriver", Convert.ToString(row[0]));
+                if (null != odbcDriver)
+                {
+                    odbcDriver.AddChild(property);
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Driver_", Convert.ToString(row[0]), "ODBCDriver"));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the ODBCDataSource table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileODBCDataSourceTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.ODBCDataSource odbcDataSource = new Wix.ODBCDataSource();
+
+                odbcDataSource.Id = Convert.ToString(row[0]);
+
+                odbcDataSource.Name = Convert.ToString(row[2]);
+
+                odbcDataSource.DriverName = Convert.ToString(row[3]);
+
+                switch (Convert.ToInt32(row[4]))
+                {
+                    case MsiInterop.MsidbODBCDataSourceRegistrationPerMachine:
+                        odbcDataSource.Registration = Wix.ODBCDataSource.RegistrationType.machine;
+                        break;
+                    case MsiInterop.MsidbODBCDataSourceRegistrationPerUser:
+                        odbcDataSource.Registration = Wix.ODBCDataSource.RegistrationType.user;
+                        break;
+                    default:
+                        this.core.OnMessage(WixWarnings.IllegalColumnValue(row.SourceLineNumbers, table.Name, row.Fields[4].Column.Name, row[4]));
+                        break;
+                }
+
+                this.core.IndexElement(row, odbcDataSource);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the ODBCDriver table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileODBCDriverTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.ODBCDriver odbcDriver = new Wix.ODBCDriver();
+
+                odbcDriver.Id = Convert.ToString(row[0]);
+
+                odbcDriver.Name = Convert.ToString(row[2]);
+
+                odbcDriver.File = Convert.ToString(row[3]);
+
+                if (null != row[4])
+                {
+                    odbcDriver.SetupFile = Convert.ToString(row[4]);
+                }
+
+                Wix.Component component = (Wix.Component)this.core.GetIndexedElement("Component", Convert.ToString(row[1]));
+                if (null != component)
+                {
+                    component.AddChild(odbcDriver);
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", Convert.ToString(row[1]), "Component"));
+                }
+                this.core.IndexElement(row, odbcDriver);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the ODBCSourceAttribute table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileODBCSourceAttributeTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.Property property = new Wix.Property();
+
+                property.Id = Convert.ToString(row[1]);
+
+                if (null != row[2])
+                {
+                    property.Value = Convert.ToString(row[2]);
+                }
+
+                Wix.ODBCDataSource odbcDataSource = (Wix.ODBCDataSource)this.core.GetIndexedElement("ODBCDataSource", Convert.ToString(row[0]));
+                if (null != odbcDataSource)
+                {
+                    odbcDataSource.AddChild(property);
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "DataSource_", Convert.ToString(row[0]), "ODBCDataSource"));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the ODBCTranslator table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileODBCTranslatorTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.ODBCTranslator odbcTranslator = new Wix.ODBCTranslator();
+
+                odbcTranslator.Id = Convert.ToString(row[0]);
+
+                odbcTranslator.Name = Convert.ToString(row[2]);
+
+                odbcTranslator.File = Convert.ToString(row[3]);
+
+                if (null != row[4])
+                {
+                    odbcTranslator.SetupFile = Convert.ToString(row[4]);
+                }
+
+                Wix.Component component = (Wix.Component)this.core.GetIndexedElement("Component", Convert.ToString(row[1]));
+                if (null != component)
+                {
+                    component.AddChild(odbcTranslator);
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", Convert.ToString(row[1]), "Component"));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the PatchMetadata table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompilePatchMetadataTable(Table table)
+        {
+            if (0 < table.Rows.Count)
+            {
+                Wix.PatchMetadata patchMetadata = new Wix.PatchMetadata();
+
+                foreach (Row row in table.Rows)
+                {
+                    string value = Convert.ToString(row[2]);
+
+                    switch (Convert.ToString(row[1]))
+                    {
+                        case "AllowRemoval":
+                            if ("1" == value)
+                            {
+                                patchMetadata.AllowRemoval = Wix.YesNoType.yes;
+                            }
+                            break;
+                        case "Classification":
+                            if (null != value)
+                            {
+                                patchMetadata.Classification = value;
+                            }
+                            break;
+                        case "CreationTimeUTC":
+                            if (null != value)
+                            {
+                                patchMetadata.CreationTimeUTC = value;
+                            }
+                            break;
+                        case "Description":
+                            if (null != value)
+                            {
+                                patchMetadata.Description = value;
+                            }
+                            break;
+                        case "DisplayName":
+                            if (null != value)
+                            {
+                                patchMetadata.DisplayName = value;
+                            }
+                            break;
+                        case "ManufacturerName":
+                            if (null != value)
+                            {
+                                patchMetadata.ManufacturerName = value;
+                            }
+                            break;
+                        case "MinorUpdateTargetRTM":
+                            if (null != value)
+                            {
+                                patchMetadata.MinorUpdateTargetRTM = value;
+                            }
+                            break;
+                        case "MoreInfoURL":
+                            if (null != value)
+                            {
+                                patchMetadata.MoreInfoURL = value;
+                            }
+                            break;
+                        case "OptimizeCA":
+                            Wix.OptimizeCustomActions optimizeCustomActions = new Wix.OptimizeCustomActions();
+                            int optimizeCA = Int32.Parse(value, CultureInfo.InvariantCulture);
+                            if (0 != (Convert.ToInt32(OptimizeCA.SkipAssignment) & optimizeCA))
+                            {
+                                optimizeCustomActions.SkipAssignment = Wix.YesNoType.yes;
+                            }
+
+                            if (0 != (Convert.ToInt32(OptimizeCA.SkipImmediate) & optimizeCA))
+                            {
+                                optimizeCustomActions.SkipImmediate = Wix.YesNoType.yes;
+                            }
+
+                            if (0 != (Convert.ToInt32(OptimizeCA.SkipDeferred) & optimizeCA))
+                            {
+                                optimizeCustomActions.SkipDeferred = Wix.YesNoType.yes;
+                            }
+
+                            patchMetadata.AddChild(optimizeCustomActions);
+                            break;
+                        case "OptimizedInstallMode":
+                            if ("1" == value)
+                            {
+                                patchMetadata.OptimizedInstallMode = Wix.YesNoType.yes;
+                            }
+                            break;
+                        case "TargetProductName":
+                            if (null != value)
+                            {
+                                patchMetadata.TargetProductName = value;
+                            }
+                            break;
+                        default:
+                            Wix.CustomProperty customProperty = new Wix.CustomProperty();
+
+                            if (null != row[0])
+                            {
+                                customProperty.Company = Convert.ToString(row[0]);
+                            }
+
+                            customProperty.Property = Convert.ToString(row[1]);
+
+                            if (null != row[2])
+                            {
+                                customProperty.Value = Convert.ToString(row[2]);
+                            }
+
+                            patchMetadata.AddChild(customProperty);
+                            break;
+                    }
+                }
+
+                this.core.RootElement.AddChild(patchMetadata);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the PatchSequence table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompilePatchSequenceTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.PatchSequence patchSequence = new Wix.PatchSequence();
+
+                patchSequence.PatchFamily = Convert.ToString(row[0]);
+
+                if (null != row[1])
+                {
+                    try
+                    {
+                        Guid guid = new Guid(Convert.ToString(row[1]));
+
+                        patchSequence.ProductCode = Convert.ToString(row[1]);
+                    }
+                    catch // non-guid value
+                    {
+                        patchSequence.TargetImage = Convert.ToString(row[1]);
+                    }
+                }
+
+                if (null != row[2])
+                {
+                    patchSequence.Sequence = Convert.ToString(row[2]);
+                }
+
+                if (null != row[3] && 0x1 == Convert.ToInt32(row[3]))
+                {
+                    patchSequence.Supersede = Wix.YesNoType.yes;
+                }
+
+                this.core.RootElement.AddChild(patchSequence);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the ProgId table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileProgIdTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.ProgId progId = new Wix.ProgId();
+
+                progId.Advertise = Wix.YesNoType.yes;
+
+                progId.Id = Convert.ToString(row[0]);
+
+                if (null != row[3])
+                {
+                    progId.Description = Convert.ToString(row[3]);
+                }
+
+                if (null != row[4])
+                {
+                    progId.Icon = Convert.ToString(row[4]);
+                }
+
+                if (null != row[5])
+                {
+                    progId.IconIndex = Convert.ToInt32(row[5]);
+                }
+
+                this.core.IndexElement(row, progId);
+            }
+
+            // nest the ProgIds
+            foreach (Row row in table.Rows)
+            {
+                Wix.ProgId progId = (Wix.ProgId)this.core.GetIndexedElement(row);
+
+                if (null != row[1])
+                {
+                    Wix.ProgId parentProgId = (Wix.ProgId)this.core.GetIndexedElement("ProgId", Convert.ToString(row[1]));
+
+                    if (null != parentProgId)
+                    {
+                        parentProgId.AddChild(progId);
+                    }
+                    else
+                    {
+                        this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "ProgId_Parent", Convert.ToString(row[1]), "ProgId"));
+                    }
+                }
+                else if (null != row[2])
+                {
+                    // nesting is handled in FinalizeProgIdTable
+                }
+                else
+                {
+                    // TODO: warn for orphaned ProgId
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the Properties table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompilePropertiesTable(Table table)
+        {
+            Wix.PatchCreation patchCreation = (Wix.PatchCreation)this.core.RootElement;
+
+            foreach (Row row in table.Rows)
+            {
+                string name = Convert.ToString(row[0]);
+                string value = Convert.ToString(row[1]);
+
+                switch (name)
+                {
+                    case "AllowProductCodeMismatches":
+                        if ("1" == value)
+                        {
+                            patchCreation.AllowProductCodeMismatches = Wix.YesNoType.yes;
+                        }
+                        break;
+                    case "AllowProductVersionMajorMismatches":
+                        if ("1" == value)
+                        {
+                            patchCreation.AllowMajorVersionMismatches = Wix.YesNoType.yes;
+                        }
+                        break;
+                    case "ApiPatchingSymbolFlags":
+                        if (null != value)
+                        {
+                            try
+                            {
+                                // remove the leading "0x" if its present
+                                if (value.StartsWith("0x", StringComparison.Ordinal))
+                                {
+                                    value = value.Substring(2);
+                                }
+
+                                patchCreation.SymbolFlags = Convert.ToInt32(value, 16);
+                            }
+                            catch
+                            {
+                                this.core.OnMessage(WixWarnings.IllegalColumnValue(row.SourceLineNumbers, table.Name, row.Fields[1].Column.Name, row[1]));
+                            }
+                        }
+                        break;
+                    case "DontRemoveTempFolderWhenFinished":
+                        if ("1" == value)
+                        {
+                            patchCreation.CleanWorkingFolder = Wix.YesNoType.no;
+                        }
+                        break;
+                    case "IncludeWholeFilesOnly":
+                        if ("1" == value)
+                        {
+                            patchCreation.WholeFilesOnly = Wix.YesNoType.yes;
+                        }
+                        break;
+                    case "ListOfPatchGUIDsToReplace":
+                        if (null != value)
+                        {
+                            Regex guidRegex = new Regex(@"\{[0-9A-Fa-f]{8}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{4}-[0-9A-Fa-f]{12}\}");
+                            MatchCollection guidMatches = guidRegex.Matches(value);
+
+                            foreach (Match guidMatch in guidMatches)
+                            {
+                                Wix.ReplacePatch replacePatch = new Wix.ReplacePatch();
+
+                                replacePatch.Id = guidMatch.Value;
+
+                                this.core.RootElement.AddChild(replacePatch);
+                            }
+                        }
+                        break;
+                    case "ListOfTargetProductCodes":
+                        if (null != value)
+                        {
+                            string[] targetProductCodes = value.Split(';');
+
+                            foreach (string targetProductCodeString in targetProductCodes)
+                            {
+                                Wix.TargetProductCode targetProductCode = new Wix.TargetProductCode();
+
+                                targetProductCode.Id = targetProductCodeString;
+
+                                this.core.RootElement.AddChild(targetProductCode);
+                            }
+                        }
+                        break;
+                    case "PatchGUID":
+                        patchCreation.Id = value;
+                        break;
+                    case "PatchSourceList":
+                        patchCreation.SourceList = value;
+                        break;
+                    case "PatchOutputPath":
+                        patchCreation.OutputPath = value;
+                        break;
+                    default:
+                        Wix.PatchProperty patchProperty = new Wix.PatchProperty();
+
+                        patchProperty.Name = name;
+
+                        patchProperty.Value = value;
+
+                        this.core.RootElement.AddChild(patchProperty);
+                        break;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the Property table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompilePropertyTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                string id = Convert.ToString(row[0]);
+                string value = Convert.ToString(row[1]);
+
+                if ("AdminProperties" == id || "MsiHiddenProperties" == id || "SecureCustomProperties" == id)
+                {
+                    if (0 < value.Length)
+                    {
+                        foreach (string propertyId in value.Split(';'))
+                        {
+                            string property = propertyId;
+                            bool suppressModulularization = false;
+                            if (OutputType.Module == this.outputType)
+                            {
+                                if (propertyId.EndsWith(this.modularizationGuid.Substring(1, 36).Replace('-', '_'), StringComparison.Ordinal))
+                                {
+                                    property = propertyId.Substring(0, propertyId.Length - this.modularizationGuid.Length + 1);
+                                }
+                                else
+                                {
+                                    suppressModulularization = true;
+                                }
+                            }
+
+                            Wix.Property specialProperty = this.EnsureProperty(property);
+                            if (suppressModulularization)
+                            {
+                                specialProperty.SuppressModularization = Wix.YesNoType.yes;
+                            }
+
+                            switch (id)
+                            {
+                                case "AdminProperties":
+                                    specialProperty.Admin = Wix.YesNoType.yes;
+                                    break;
+                                case "MsiHiddenProperties":
+                                    specialProperty.Hidden = Wix.YesNoType.yes;
+                                    break;
+                                case "SecureCustomProperties":
+                                    specialProperty.Secure = Wix.YesNoType.yes;
+                                    break;
+                            }
+                        }
+                    }
+
+                    continue;
+                }
+                else if (OutputType.Product == this.outputType)
+                {
+                    Wix.Product product = (Wix.Product)this.core.RootElement;
+
+                    switch (id)
+                    {
+                        case "Manufacturer":
+                            product.Manufacturer = value;
+                            continue;
+                        case "ProductCode":
+                            product.Id = value.ToUpper(CultureInfo.InvariantCulture);
+                            continue;
+                        case "ProductLanguage":
+                            product.Language = value;
+                            continue;
+                        case "ProductName":
+                            product.Name = value;
+                            continue;
+                        case "ProductVersion":
+                            product.Version = value;
+                            continue;
+                        case "UpgradeCode":
+                            product.UpgradeCode = value;
+                            continue;
+                    }
+                }
+
+                if (!this.suppressUI || "ErrorDialog" != id)
+                {
+                    Wix.Property property = this.EnsureProperty(id);
+
+                    property.Value = value;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the PublishComponent table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompilePublishComponentTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.Category category = new Wix.Category();
+
+                category.Id = Convert.ToString(row[0]);
+
+                category.Qualifier = Convert.ToString(row[1]);
+
+                if (null != row[3])
+                {
+                    category.AppData = Convert.ToString(row[3]);
+                }
+
+                Wix.Component component = (Wix.Component)this.core.GetIndexedElement("Component", Convert.ToString(row[2]));
+                if (null != component)
+                {
+                    component.AddChild(category);
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", Convert.ToString(row[2]), "Component"));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the RadioButton table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileRadioButtonTable(Table table)
+        {
+            SortedList radioButtons = new SortedList();
+            Hashtable radioButtonGroups = new Hashtable();
+
+            foreach (Row row in table.Rows)
+            {
+                Wix.RadioButton radioButton = new Wix.RadioButton();
+
+                radioButton.Value = Convert.ToString(row[2]);
+
+                radioButton.X = Convert.ToString(row[3], CultureInfo.InvariantCulture);
+
+                radioButton.Y = Convert.ToString(row[4], CultureInfo.InvariantCulture);
+
+                radioButton.Width = Convert.ToString(row[5], CultureInfo.InvariantCulture);
+
+                radioButton.Height = Convert.ToString(row[6], CultureInfo.InvariantCulture);
+
+                if (null != row[7])
+                {
+                    radioButton.Text = Convert.ToString(row[7]);
+                }
+
+                if (null != row[8])
+                {
+                    string[] help = (Convert.ToString(row[8])).Split('|');
+
+                    if (2 == help.Length)
+                    {
+                        if (0 < help[0].Length)
+                        {
+                            radioButton.ToolTip = help[0];
+                        }
+
+                        if (0 < help[1].Length)
+                        {
+                            radioButton.Help = help[1];
+                        }
+                    }
+                }
+
+                radioButtons.Add(String.Format(CultureInfo.InvariantCulture, "{0}|{1:0000000000}", row[0], row[1]), row);
+                this.core.IndexElement(row, radioButton);
+            }
+
+            // nest the radio buttons
+            foreach (Row row in radioButtons.Values)
+            {
+                Wix.RadioButton radioButton = (Wix.RadioButton)this.core.GetIndexedElement(row);
+                Wix.RadioButtonGroup radioButtonGroup = (Wix.RadioButtonGroup)radioButtonGroups[Convert.ToString(row[0])];
+
+                if (null == radioButtonGroup)
+                {
+                    radioButtonGroup = new Wix.RadioButtonGroup();
+
+                    radioButtonGroup.Property = Convert.ToString(row[0]);
+
+                    this.core.UIElement.AddChild(radioButtonGroup);
+                    radioButtonGroups.Add(Convert.ToString(row[0]), radioButtonGroup);
+                }
+
+                radioButtonGroup.AddChild(radioButton);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the Registry table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileRegistryTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                if (("-" == Convert.ToString(row[3]) || "+" == Convert.ToString(row[3]) || "*" == Convert.ToString(row[3])) && null == row[4])
+                {
+                    Wix.RegistryKey registryKey = new Wix.RegistryKey();
+
+                    registryKey.Id = Convert.ToString(row[0]);
+
+                    Wix.RegistryRootType registryRootType;
+                    if (this.GetRegistryRootType(row.SourceLineNumbers, table.Name, row.Fields[1], out registryRootType))
+                    {
+                        registryKey.Root = registryRootType;
+                    }
+
+                    registryKey.Key = Convert.ToString(row[2]);
+
+                    switch (Convert.ToString(row[3]))
+                    {
+                        case "+":
+                            registryKey.ForceCreateOnInstall = Wix.YesNoType.yes;
+                            break;
+                        case "-":
+                            registryKey.ForceDeleteOnUninstall = Wix.YesNoType.yes;
+                            break;
+                        case "*":
+                            registryKey.ForceDeleteOnUninstall = Wix.YesNoType.yes;
+                            registryKey.ForceCreateOnInstall = Wix.YesNoType.yes;
+                            break;
+                    }
+
+                    this.core.IndexElement(row, registryKey);
+                }
+                else
+                {
+                    Wix.RegistryValue registryValue = new Wix.RegistryValue();
+
+                    registryValue.Id = Convert.ToString(row[0]);
+
+                    Wix.RegistryRootType registryRootType;
+                    if (this.GetRegistryRootType(row.SourceLineNumbers, table.Name, row.Fields[1], out registryRootType))
+                    {
+                        registryValue.Root = registryRootType;
+                    }
+
+                    registryValue.Key = Convert.ToString(row[2]);
+
+                    if (null != row[3])
+                    {
+                        registryValue.Name = Convert.ToString(row[3]);
+                    }
+
+                    if (null != row[4])
+                    {
+                        string value = Convert.ToString(row[4]);
+
+                        if (value.StartsWith("#x", StringComparison.Ordinal))
+                        {
+                            registryValue.Type = Wix.RegistryValue.TypeType.binary;
+                            registryValue.Value = value.Substring(2);
+                        }
+                        else if (value.StartsWith("#%", StringComparison.Ordinal))
+                        {
+                            registryValue.Type = Wix.RegistryValue.TypeType.expandable;
+                            registryValue.Value = value.Substring(2);
+                        }
+                        else if (value.StartsWith("#", StringComparison.Ordinal) && !value.StartsWith("##", StringComparison.Ordinal))
+                        {
+                            registryValue.Type = Wix.RegistryValue.TypeType.integer;
+                            registryValue.Value = value.Substring(1);
+                        }
+                        else
+                        {
+                            if (value.StartsWith("##", StringComparison.Ordinal))
+                            {
+                                value = value.Substring(1);
+                            }
+
+                            if (0 <= value.IndexOf("[~]", StringComparison.Ordinal))
+                            {
+                                registryValue.Type = Wix.RegistryValue.TypeType.multiString;
+
+                                if ("[~]" == value)
+                                {
+                                    value = string.Empty;
+                                }
+                                else if (value.StartsWith("[~]", StringComparison.Ordinal) && value.EndsWith("[~]", StringComparison.Ordinal))
+                                {
+                                    value = value.Substring(3, value.Length - 6);
+                                }
+                                else if (value.StartsWith("[~]", StringComparison.Ordinal))
+                                {
+                                    registryValue.Action = Wix.RegistryValue.ActionType.append;
+                                    value = value.Substring(3);
+                                }
+                                else if (value.EndsWith("[~]", StringComparison.Ordinal))
+                                {
+                                    registryValue.Action = Wix.RegistryValue.ActionType.prepend;
+                                    value = value.Substring(0, value.Length - 3);
+                                }
+
+                                string[] multiValues = NullSplitter.Split(value);
+                                foreach (string multiValue in multiValues)
+                                {
+                                    Wix.MultiStringValue multiStringValue = new Wix.MultiStringValue();
+
+                                    multiStringValue.Content = multiValue;
+
+                                    registryValue.AddChild(multiStringValue);
+                                }
+                            }
+                            else
+                            {
+                                registryValue.Type = Wix.RegistryValue.TypeType.@string;
+                                registryValue.Value = value;
+                            }
+                        }
+                    }
+                    else
+                    {
+                        registryValue.Type = Wix.RegistryValue.TypeType.@string;
+                        registryValue.Value = String.Empty;
+                    }
+
+                    this.core.IndexElement(row, registryValue);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the RegLocator table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileRegLocatorTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.RegistrySearch registrySearch = new Wix.RegistrySearch();
+
+                registrySearch.Id = Convert.ToString(row[0]);
+
+                switch (Convert.ToInt32(row[1]))
+                {
+                    case MsiInterop.MsidbRegistryRootClassesRoot:
+                        registrySearch.Root = Wix.RegistrySearch.RootType.HKCR;
+                        break;
+                    case MsiInterop.MsidbRegistryRootCurrentUser:
+                        registrySearch.Root = Wix.RegistrySearch.RootType.HKCU;
+                        break;
+                    case MsiInterop.MsidbRegistryRootLocalMachine:
+                        registrySearch.Root = Wix.RegistrySearch.RootType.HKLM;
+                        break;
+                    case MsiInterop.MsidbRegistryRootUsers:
+                        registrySearch.Root = Wix.RegistrySearch.RootType.HKU;
+                        break;
+                    default:
+                        this.core.OnMessage(WixWarnings.IllegalColumnValue(row.SourceLineNumbers, table.Name, row.Fields[1].Column.Name, row[1]));
+                        break;
+                }
+
+                registrySearch.Key = Convert.ToString(row[2]);
+
+                if (null != row[3])
+                {
+                    registrySearch.Name = Convert.ToString(row[3]);
+                }
+
+                if (null == row[4])
+                {
+                    registrySearch.Type = Wix.RegistrySearch.TypeType.file;
+                }
+                else
+                {
+                    int type = Convert.ToInt32(row[4]);
+
+                    if (MsiInterop.MsidbLocatorType64bit == (type & MsiInterop.MsidbLocatorType64bit))
+                    {
+                        registrySearch.Win64 = Wix.YesNoType.yes;
+                        type &= ~MsiInterop.MsidbLocatorType64bit;
+                    }
+
+                    switch (type)
+                    {
+                        case MsiInterop.MsidbLocatorTypeDirectory:
+                            registrySearch.Type = Wix.RegistrySearch.TypeType.directory;
+                            break;
+                        case MsiInterop.MsidbLocatorTypeFileName:
+                            registrySearch.Type = Wix.RegistrySearch.TypeType.file;
+                            break;
+                        case MsiInterop.MsidbLocatorTypeRawValue:
+                            registrySearch.Type = Wix.RegistrySearch.TypeType.raw;
+                            break;
+                        default:
+                            this.core.OnMessage(WixWarnings.IllegalColumnValue(row.SourceLineNumbers, table.Name, row.Fields[4].Column.Name, row[4]));
+                            break;
+                    }
+                }
+
+                this.core.IndexElement(row, registrySearch);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the RemoveFile table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileRemoveFileTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                if (null == row[2])
+                {
+                    Wix.RemoveFolder removeFolder = new Wix.RemoveFolder();
+
+                    removeFolder.Id = Convert.ToString(row[0]);
+
+                    // directory/property is set in FinalizeDecompile
+
+                    switch (Convert.ToInt32(row[4]))
+                    {
+                        case MsiInterop.MsidbRemoveFileInstallModeOnInstall:
+                            removeFolder.On = Wix.InstallUninstallType.install;
+                            break;
+                        case MsiInterop.MsidbRemoveFileInstallModeOnRemove:
+                            removeFolder.On = Wix.InstallUninstallType.uninstall;
+                            break;
+                        case MsiInterop.MsidbRemoveFileInstallModeOnBoth:
+                            removeFolder.On = Wix.InstallUninstallType.both;
+                            break;
+                        default:
+                            this.core.OnMessage(WixWarnings.IllegalColumnValue(row.SourceLineNumbers, table.Name, row.Fields[4].Column.Name, row[4]));
+                            break;
+                    }
+
+                    Wix.Component component = (Wix.Component)this.core.GetIndexedElement("Component", Convert.ToString(row[1]));
+                    if (null != component)
+                    {
+                        component.AddChild(removeFolder);
+                    }
+                    else
+                    {
+                        this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", Convert.ToString(row[1]), "Component"));
+                    }
+                    this.core.IndexElement(row, removeFolder);
+                }
+                else
+                {
+                    Wix.RemoveFile removeFile = new Wix.RemoveFile();
+
+                    removeFile.Id = Convert.ToString(row[0]);
+
+                    string[] names = Installer.GetNames(Convert.ToString(row[2]));
+                    if (null != names[0] && null != names[1])
+                    {
+                        removeFile.ShortName = names[0];
+                        removeFile.Name = names[1];
+                    }
+                    else if (null != names[0])
+                    {
+                        removeFile.Name = names[0];
+                    }
+
+                    // directory/property is set in FinalizeDecompile
+
+                    switch (Convert.ToInt32(row[4]))
+                    {
+                        case MsiInterop.MsidbRemoveFileInstallModeOnInstall:
+                            removeFile.On = Wix.InstallUninstallType.install;
+                            break;
+                        case MsiInterop.MsidbRemoveFileInstallModeOnRemove:
+                            removeFile.On = Wix.InstallUninstallType.uninstall;
+                            break;
+                        case MsiInterop.MsidbRemoveFileInstallModeOnBoth:
+                            removeFile.On = Wix.InstallUninstallType.both;
+                            break;
+                        default:
+                            this.core.OnMessage(WixWarnings.IllegalColumnValue(row.SourceLineNumbers, table.Name, row.Fields[4].Column.Name, row[4]));
+                            break;
+                    }
+
+                    Wix.Component component = (Wix.Component)this.core.GetIndexedElement("Component", Convert.ToString(row[1]));
+                    if (null != component)
+                    {
+                        component.AddChild(removeFile);
+                    }
+                    else
+                    {
+                        this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", Convert.ToString(row[1]), "Component"));
+                    }
+                    this.core.IndexElement(row, removeFile);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the RemoveIniFile table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileRemoveIniFileTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.IniFile iniFile = new Wix.IniFile();
+
+                iniFile.Id = Convert.ToString(row[0]);
+
+                string[] names = Installer.GetNames(Convert.ToString(row[1]));
+                if (null != names[0] && null != names[1])
+                {
+                    iniFile.ShortName = names[0];
+                    iniFile.Name = names[1];
+                }
+                else if (null != names[0])
+                {
+                    iniFile.Name = names[0];
+                }
+
+                if (null != row[2])
+                {
+                    iniFile.Directory = Convert.ToString(row[2]);
+                }
+
+                iniFile.Section = Convert.ToString(row[3]);
+
+                iniFile.Key = Convert.ToString(row[4]);
+
+                if (null != row[5])
+                {
+                    iniFile.Value = Convert.ToString(row[5]);
+                }
+
+                switch (Convert.ToInt32(row[6]))
+                {
+                    case MsiInterop.MsidbIniFileActionRemoveLine:
+                        iniFile.Action = Wix.IniFile.ActionType.removeLine;
+                        break;
+                    case MsiInterop.MsidbIniFileActionRemoveTag:
+                        iniFile.Action = Wix.IniFile.ActionType.removeTag;
+                        break;
+                    default:
+                        this.core.OnMessage(WixWarnings.IllegalColumnValue(row.SourceLineNumbers, table.Name, row.Fields[6].Column.Name, row[6]));
+                        break;
+                }
+
+                Wix.Component component = (Wix.Component)this.core.GetIndexedElement("Component", Convert.ToString(row[7]));
+                if (null != component)
+                {
+                    component.AddChild(iniFile);
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", Convert.ToString(row[7]), "Component"));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the RemoveRegistry table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileRemoveRegistryTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                if ("-" == Convert.ToString(row[3]))
+                {
+                    Wix.RemoveRegistryKey removeRegistryKey = new Wix.RemoveRegistryKey();
+
+                    removeRegistryKey.Id = Convert.ToString(row[0]);
+
+                    Wix.RegistryRootType registryRootType;
+                    if (this.GetRegistryRootType(row.SourceLineNumbers, table.Name, row.Fields[1], out registryRootType))
+                    {
+                        removeRegistryKey.Root = registryRootType;
+                    }
+
+                    removeRegistryKey.Key = Convert.ToString(row[2]);
+
+                    removeRegistryKey.Action = Wix.RemoveRegistryKey.ActionType.removeOnInstall;
+
+                    Wix.Component component = (Wix.Component)this.core.GetIndexedElement("Component", Convert.ToString(row[4]));
+                    if (null != component)
+                    {
+                        component.AddChild(removeRegistryKey);
+                    }
+                    else
+                    {
+                        this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", Convert.ToString(row[4]), "Component"));
+                    }
+                }
+                else
+                {
+                    Wix.RemoveRegistryValue removeRegistryValue = new Wix.RemoveRegistryValue();
+
+                    removeRegistryValue.Id = Convert.ToString(row[0]);
+
+                    Wix.RegistryRootType registryRootType;
+                    if (this.GetRegistryRootType(row.SourceLineNumbers, table.Name, row.Fields[1], out registryRootType))
+                    {
+                        removeRegistryValue.Root = registryRootType;
+                    }
+
+                    removeRegistryValue.Key = Convert.ToString(row[2]);
+
+                    if (null != row[3])
+                    {
+                        removeRegistryValue.Name = Convert.ToString(row[3]);
+                    }
+
+                    Wix.Component component = (Wix.Component)this.core.GetIndexedElement("Component", Convert.ToString(row[4]));
+                    if (null != component)
+                    {
+                        component.AddChild(removeRegistryValue);
+                    }
+                    else
+                    {
+                        this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", Convert.ToString(row[4]), "Component"));
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the ReserveCost table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileReserveCostTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.ReserveCost reserveCost = new Wix.ReserveCost();
+
+                reserveCost.Id = Convert.ToString(row[0]);
+
+                if (null != row[2])
+                {
+                    reserveCost.Directory = Convert.ToString(row[2]);
+                }
+
+                reserveCost.RunLocal = Convert.ToInt32(row[3]);
+
+                reserveCost.RunFromSource = Convert.ToInt32(row[4]);
+
+                Wix.Component component = (Wix.Component)this.core.GetIndexedElement("Component", Convert.ToString(row[1]));
+                if (null != component)
+                {
+                    component.AddChild(reserveCost);
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", Convert.ToString(row[1]), "Component"));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the SelfReg table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileSelfRegTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.File file = (Wix.File)this.core.GetIndexedElement("File", Convert.ToString(row[0]));
+
+                if (null != file)
+                {
+                    if (null != row[1])
+                    {
+                        file.SelfRegCost = Convert.ToInt32(row[1]);
+                    }
+                    else
+                    {
+                        file.SelfRegCost = 0;
+                    }
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "File_", Convert.ToString(row[0]), "File"));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the ServiceControl table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileServiceControlTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.ServiceControl serviceControl = new Wix.ServiceControl();
+
+                serviceControl.Id = Convert.ToString(row[0]);
+
+                serviceControl.Name = Convert.ToString(row[1]);
+
+                int eventValue = Convert.ToInt32(row[2]);
+                if (MsiInterop.MsidbServiceControlEventStart == (eventValue & MsiInterop.MsidbServiceControlEventStart) &&
+                    MsiInterop.MsidbServiceControlEventUninstallStart == (eventValue & MsiInterop.MsidbServiceControlEventUninstallStart))
+                {
+                    serviceControl.Start = Wix.InstallUninstallType.both;
+                }
+                else if (MsiInterop.MsidbServiceControlEventStart == (eventValue & MsiInterop.MsidbServiceControlEventStart))
+                {
+                    serviceControl.Start = Wix.InstallUninstallType.install;
+                }
+                else if (MsiInterop.MsidbServiceControlEventUninstallStart == (eventValue & MsiInterop.MsidbServiceControlEventUninstallStart))
+                {
+                    serviceControl.Start = Wix.InstallUninstallType.uninstall;
+                }
+
+                if (MsiInterop.MsidbServiceControlEventStop == (eventValue & MsiInterop.MsidbServiceControlEventStop) &&
+                    MsiInterop.MsidbServiceControlEventUninstallStop == (eventValue & MsiInterop.MsidbServiceControlEventUninstallStop))
+                {
+                    serviceControl.Stop = Wix.InstallUninstallType.both;
+                }
+                else if (MsiInterop.MsidbServiceControlEventStop == (eventValue & MsiInterop.MsidbServiceControlEventStop))
+                {
+                    serviceControl.Stop = Wix.InstallUninstallType.install;
+                }
+                else if (MsiInterop.MsidbServiceControlEventUninstallStop == (eventValue & MsiInterop.MsidbServiceControlEventUninstallStop))
+                {
+                    serviceControl.Stop = Wix.InstallUninstallType.uninstall;
+                }
+
+                if (MsiInterop.MsidbServiceControlEventDelete == (eventValue & MsiInterop.MsidbServiceControlEventDelete) &&
+                    MsiInterop.MsidbServiceControlEventUninstallDelete == (eventValue & MsiInterop.MsidbServiceControlEventUninstallDelete))
+                {
+                    serviceControl.Remove = Wix.InstallUninstallType.both;
+                }
+                else if (MsiInterop.MsidbServiceControlEventDelete == (eventValue & MsiInterop.MsidbServiceControlEventDelete))
+                {
+                    serviceControl.Remove = Wix.InstallUninstallType.install;
+                }
+                else if (MsiInterop.MsidbServiceControlEventUninstallDelete == (eventValue & MsiInterop.MsidbServiceControlEventUninstallDelete))
+                {
+                    serviceControl.Remove = Wix.InstallUninstallType.uninstall;
+                }
+
+                if (null != row[3])
+                {
+                    string[] arguments = NullSplitter.Split(Convert.ToString(row[3]));
+
+                    foreach (string argument in arguments)
+                    {
+                        Wix.ServiceArgument serviceArgument = new Wix.ServiceArgument();
+
+                        serviceArgument.Content = argument;
+
+                        serviceControl.AddChild(serviceArgument);
+                    }
+                }
+
+                if (null != row[4])
+                {
+                    if (0 == Convert.ToInt32(row[4]))
+                    {
+                        serviceControl.Wait = Wix.YesNoType.no;
+                    }
+                    else
+                    {
+                        serviceControl.Wait = Wix.YesNoType.yes;
+                    }
+                }
+
+                Wix.Component component = (Wix.Component)this.core.GetIndexedElement("Component", Convert.ToString(row[5]));
+                if (null != component)
+                {
+                    component.AddChild(serviceControl);
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", Convert.ToString(row[5]), "Component"));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the ServiceInstall table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileServiceInstallTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.ServiceInstall serviceInstall = new Wix.ServiceInstall();
+
+                serviceInstall.Id = Convert.ToString(row[0]);
+
+                serviceInstall.Name = Convert.ToString(row[1]);
+
+                if (null != row[2])
+                {
+                    serviceInstall.DisplayName = Convert.ToString(row[2]);
+                }
+
+                int serviceType = Convert.ToInt32(row[3]);
+                if (MsiInterop.MsidbServiceInstallInteractive == (serviceType & MsiInterop.MsidbServiceInstallInteractive))
+                {
+                    serviceInstall.Interactive = Wix.YesNoType.yes;
+                }
+
+                if (MsiInterop.MsidbServiceInstallOwnProcess == (serviceType & MsiInterop.MsidbServiceInstallOwnProcess) &&
+                    MsiInterop.MsidbServiceInstallShareProcess == (serviceType & MsiInterop.MsidbServiceInstallShareProcess))
+                {
+                    // TODO: warn
+                }
+                else if (MsiInterop.MsidbServiceInstallOwnProcess == (serviceType & MsiInterop.MsidbServiceInstallOwnProcess))
+                {
+                    serviceInstall.Type = Wix.ServiceInstall.TypeType.ownProcess;
+                }
+                else if (MsiInterop.MsidbServiceInstallShareProcess == (serviceType & MsiInterop.MsidbServiceInstallShareProcess))
+                {
+                    serviceInstall.Type = Wix.ServiceInstall.TypeType.shareProcess;
+                }
+
+                int startType = Convert.ToInt32(row[4]);
+                if (MsiInterop.MsidbServiceInstallDisabled == startType)
+                {
+                    serviceInstall.Start = Wix.ServiceInstall.StartType.disabled;
+                }
+                else if (MsiInterop.MsidbServiceInstallDemandStart == startType)
+                {
+                    serviceInstall.Start = Wix.ServiceInstall.StartType.demand;
+                }
+                else if (MsiInterop.MsidbServiceInstallAutoStart == startType)
+                {
+                    serviceInstall.Start = Wix.ServiceInstall.StartType.auto;
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.IllegalColumnValue(row.SourceLineNumbers, table.Name, row.Fields[4].Column.Name, row[4]));
+                }
+
+                int errorControl = Convert.ToInt32(row[5]);
+                if (MsiInterop.MsidbServiceInstallErrorCritical == (errorControl & MsiInterop.MsidbServiceInstallErrorCritical))
+                {
+                    serviceInstall.ErrorControl = Wix.ServiceInstall.ErrorControlType.critical;
+                }
+                else if (MsiInterop.MsidbServiceInstallErrorNormal == (errorControl & MsiInterop.MsidbServiceInstallErrorNormal))
+                {
+                    serviceInstall.ErrorControl = Wix.ServiceInstall.ErrorControlType.normal;
+                }
+                else
+                {
+                    serviceInstall.ErrorControl = Wix.ServiceInstall.ErrorControlType.ignore;
+                }
+
+                if (MsiInterop.MsidbServiceInstallErrorControlVital == (errorControl & MsiInterop.MsidbServiceInstallErrorControlVital))
+                {
+                    serviceInstall.Vital = Wix.YesNoType.yes;
+                }
+
+                if (null != row[6])
+                {
+                    serviceInstall.LoadOrderGroup = Convert.ToString(row[6]);
+                }
+
+                if (null != row[7])
+                {
+                    string[] dependencies = NullSplitter.Split(Convert.ToString(row[7]));
+
+                    foreach (string dependency in dependencies)
+                    {
+                        if (0 < dependency.Length)
+                        {
+                            Wix.ServiceDependency serviceDependency = new Wix.ServiceDependency();
+
+                            if (dependency.StartsWith("+", StringComparison.Ordinal))
+                            {
+                                serviceDependency.Group = Wix.YesNoType.yes;
+                                serviceDependency.Id = dependency.Substring(1);
+                            }
+                            else
+                            {
+                                serviceDependency.Id = dependency;
+                            }
+
+                            serviceInstall.AddChild(serviceDependency);
+                        }
+                    }
+                }
+
+                if (null != row[8])
+                {
+                    serviceInstall.Account = Convert.ToString(row[8]);
+                }
+
+                if (null != row[9])
+                {
+                    serviceInstall.Password = Convert.ToString(row[9]);
+                }
+
+                if (null != row[10])
+                {
+                    serviceInstall.Arguments = Convert.ToString(row[10]);
+                }
+
+                if (null != row[12])
+                {
+                    serviceInstall.Description = Convert.ToString(row[12]);
+                }
+
+                Wix.Component component = (Wix.Component)this.core.GetIndexedElement("Component", Convert.ToString(row[11]));
+                if (null != component)
+                {
+                    component.AddChild(serviceInstall);
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", Convert.ToString(row[11]), "Component"));
+                }
+                this.core.IndexElement(row, serviceInstall);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the SFPCatalog table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileSFPCatalogTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.SFPCatalog sfpCatalog = new Wix.SFPCatalog();
+
+                sfpCatalog.Name = Convert.ToString(row[0]);
+
+                sfpCatalog.SourceFile = Convert.ToString(row[1]);
+
+                this.core.IndexElement(row, sfpCatalog);
+            }
+
+            // nest the SFPCatalog elements
+            foreach (Row row in table.Rows)
+            {
+                Wix.SFPCatalog sfpCatalog = (Wix.SFPCatalog)this.core.GetIndexedElement(row);
+
+                if (null != row[2])
+                {
+                    Wix.SFPCatalog parentSFPCatalog = (Wix.SFPCatalog)this.core.GetIndexedElement("SFPCatalog", Convert.ToString(row[2]));
+
+                    if (null != parentSFPCatalog)
+                    {
+                        parentSFPCatalog.AddChild(sfpCatalog);
+                    }
+                    else
+                    {
+                        sfpCatalog.Dependency = Convert.ToString(row[2]);
+
+                        this.core.RootElement.AddChild(sfpCatalog);
+                    }
+                }
+                else
+                {
+                    this.core.RootElement.AddChild(sfpCatalog);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the Shortcut table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileShortcutTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.Shortcut shortcut = new Wix.Shortcut();
+
+                shortcut.Id = Convert.ToString(row[0]);
+
+                shortcut.Directory = Convert.ToString(row[1]);
+
+                string[] names = Installer.GetNames(Convert.ToString(row[2]));
+                if (null != names[0] && null != names[1])
+                {
+                    shortcut.ShortName = names[0];
+                    shortcut.Name = names[1];
+                }
+                else if (null != names[0])
+                {
+                    shortcut.Name = names[0];
+                }
+
+                string target = Convert.ToString(row[4]);
+                if (target.StartsWith("[", StringComparison.Ordinal) && target.EndsWith("]", StringComparison.Ordinal))
+                {
+                    // TODO: use this value to do a "more-correct" nesting under the indicated File or CreateDirectory element
+                    shortcut.Target = target;
+                }
+                else
+                {
+                    shortcut.Advertise = Wix.YesNoType.yes;
+
+                    // primary feature is set in FinalizeFeatureComponentsTable
+                }
+
+                if (null != row[5])
+                {
+                    shortcut.Arguments = Convert.ToString(row[5]);
+                }
+
+                if (null != row[6])
+                {
+                    shortcut.Description = Convert.ToString(row[6]);
+                }
+
+                if (null != row[7])
+                {
+                    shortcut.Hotkey = Convert.ToInt32(row[7]);
+                }
+
+                if (null != row[8])
+                {
+                    shortcut.Icon = Convert.ToString(row[8]);
+                }
+
+                if (null != row[9])
+                {
+                    shortcut.IconIndex = Convert.ToInt32(row[9]);
+                }
+
+                if (null != row[10])
+                {
+                    switch (Convert.ToInt32(row[10]))
+                    {
+                        case 1:
+                            shortcut.Show = Wix.Shortcut.ShowType.normal;
+                            break;
+                        case 3:
+                            shortcut.Show = Wix.Shortcut.ShowType.maximized;
+                            break;
+                        case 7:
+                            shortcut.Show = Wix.Shortcut.ShowType.minimized;
+                            break;
+                        default:
+                            this.core.OnMessage(WixWarnings.IllegalColumnValue(row.SourceLineNumbers, table.Name, row.Fields[10].Column.Name, row[10]));
+                            break;
+                    }
+                }
+
+                if (null != row[11])
+                {
+                    shortcut.WorkingDirectory = Convert.ToString(row[11]);
+                }
+
+                // Only try to read the MSI 4.0-specific columns if they actually exist
+                if (15 < row.Fields.Length)
+                {
+                    if (null != row[12])
+                    {
+                        shortcut.DisplayResourceDll = Convert.ToString(row[12]);
+                    }
+
+                    if (null != row[13])
+                    {
+                        shortcut.DisplayResourceId = Convert.ToInt32(row[13]);
+                    }
+
+                    if (null != row[14])
+                    {
+                        shortcut.DescriptionResourceDll = Convert.ToString(row[14]);
+                    }
+
+                    if (null != row[15])
+                    {
+                        shortcut.DescriptionResourceId = Convert.ToInt32(row[15]);
+                    }
+                }
+
+                Wix.Component component = (Wix.Component)this.core.GetIndexedElement("Component", Convert.ToString(row[3]));
+                if (null != component)
+                {
+                    component.AddChild(shortcut);
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", Convert.ToString(row[3]), "Component"));
+                }
+
+                this.core.IndexElement(row, shortcut);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the Signature table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileSignatureTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.FileSearch fileSearch = new Wix.FileSearch();
+
+                fileSearch.Id = Convert.ToString(row[0]);
+
+                string[] names = Installer.GetNames(Convert.ToString(row[1]));
+                if (null != names[0])
+                {
+                    // it is permissable to just have a long name
+                    if (!this.core.IsValidShortFilename(names[0], false) && null == names[1])
+                    {
+                        fileSearch.Name = names[0];
+                    }
+                    else
+                    {
+                        fileSearch.ShortName = names[0];
+                    }
+                }
+
+                if (null != names[1])
+                {
+                    fileSearch.Name = names[1];
+                }
+
+                if (null != row[2])
+                {
+                    fileSearch.MinVersion = Convert.ToString(row[2]);
+                }
+
+                if (null != row[3])
+                {
+                    fileSearch.MaxVersion = Convert.ToString(row[3]);
+                }
+
+                if (null != row[4])
+                {
+                    fileSearch.MinSize = Convert.ToInt32(row[4]);
+                }
+
+                if (null != row[5])
+                {
+                    fileSearch.MaxSize = Convert.ToInt32(row[5]);
+                }
+
+                if (null != row[6])
+                {
+                    fileSearch.MinDate = this.core.ConvertIntegerToDateTime(Convert.ToInt32(row[6]));
+                }
+
+                if (null != row[7])
+                {
+                    fileSearch.MaxDate = this.core.ConvertIntegerToDateTime(Convert.ToInt32(row[7]));
+                }
+
+                if (null != row[8])
+                {
+                    fileSearch.Languages = Convert.ToString(row[8]);
+                }
+
+                this.core.IndexElement(row, fileSearch);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the TargetFiles_OptionalData table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileTargetFiles_OptionalDataTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.TargetFile targetFile = (Wix.TargetFile)this.patchTargetFiles[row[0]];
+                if (null == targetFile)
+                {
+                    targetFile = new Wix.TargetFile();
+
+                    targetFile.Id = Convert.ToString(row[1]);
+
+                    Wix.TargetImage targetImage = (Wix.TargetImage)this.core.GetIndexedElement("TargetImages", Convert.ToString(row[0]));
+                    if (null != targetImage)
+                    {
+                        targetImage.AddChild(targetFile);
+                    }
+                    else
+                    {
+                        this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Target", Convert.ToString(row[0]), "TargetImages"));
+                    }
+                    this.patchTargetFiles.Add(row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), targetFile);
+                }
+
+                if (null != row[2])
+                {
+                    string[] symbolPaths = (Convert.ToString(row[2])).Split(';');
+
+                    foreach (string symbolPathString in symbolPaths)
+                    {
+                        Wix.SymbolPath symbolPath = new Wix.SymbolPath();
+
+                        symbolPath.Path = symbolPathString;
+
+                        targetFile.AddChild(symbolPath);
+                    }
+                }
+
+                if (null != row[3] && null != row[4])
+                {
+                    string[] ignoreOffsets = (Convert.ToString(row[3])).Split(',');
+                    string[] ignoreLengths = (Convert.ToString(row[4])).Split(',');
+
+                    if (ignoreOffsets.Length == ignoreLengths.Length)
+                    {
+                        for (int i = 0; i < ignoreOffsets.Length; i++)
+                        {
+                            Wix.IgnoreRange ignoreRange = new Wix.IgnoreRange();
+
+                            if (ignoreOffsets[i].StartsWith("0x", StringComparison.Ordinal))
+                            {
+                                ignoreRange.Offset = Convert.ToInt32(ignoreOffsets[i].Substring(2), 16);
+                            }
+                            else
+                            {
+                                ignoreRange.Offset = Convert.ToInt32(ignoreOffsets[i], CultureInfo.InvariantCulture);
+                            }
+
+                            if (ignoreLengths[i].StartsWith("0x", StringComparison.Ordinal))
+                            {
+                                ignoreRange.Length = Convert.ToInt32(ignoreLengths[i].Substring(2), 16);
+                            }
+                            else
+                            {
+                                ignoreRange.Length = Convert.ToInt32(ignoreLengths[i], CultureInfo.InvariantCulture);
+                            }
+
+                            targetFile.AddChild(ignoreRange);
+                        }
+                    }
+                    else
+                    {
+                        // TODO: warn
+                    }
+                }
+                else if (null != row[3] || null != row[4])
+                {
+                    // TODO: warn about mismatch between columns
+                }
+
+                // the RetainOffsets column is handled in FinalizeFamilyFileRangesTable
+            }
+        }
+
+        /// <summary>
+        /// Decompile the TargetImages table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileTargetImagesTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.TargetImage targetImage = new Wix.TargetImage();
+
+                targetImage.Id = Convert.ToString(row[0]);
+
+                targetImage.SourceFile = Convert.ToString(row[1]);
+
+                if (null != row[2])
+                {
+                    string[] symbolPaths = (Convert.ToString(row[3])).Split(';');
+
+                    foreach (string symbolPathString in symbolPaths)
+                    {
+                        Wix.SymbolPath symbolPath = new Wix.SymbolPath();
+
+                        symbolPath.Path = symbolPathString;
+
+                        targetImage.AddChild(symbolPath);
+                    }
+                }
+
+                targetImage.Order = Convert.ToInt32(row[4]);
+
+                if (null != row[5])
+                {
+                    targetImage.Validation = Convert.ToString(row[5]);
+                }
+
+                if (0 != Convert.ToInt32(row[6]))
+                {
+                    targetImage.IgnoreMissingFiles = Wix.YesNoType.yes;
+                }
+
+                Wix.UpgradeImage upgradeImage = (Wix.UpgradeImage)this.core.GetIndexedElement("UpgradedImages", Convert.ToString(row[3]));
+                if (null != upgradeImage)
+                {
+                    upgradeImage.AddChild(targetImage);
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Upgraded", Convert.ToString(row[3]), "UpgradedImages"));
+                }
+                this.core.IndexElement(row, targetImage);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the TextStyle table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileTextStyleTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.TextStyle textStyle = new Wix.TextStyle();
+
+                textStyle.Id = Convert.ToString(row[0]);
+
+                textStyle.FaceName = Convert.ToString(row[1]);
+
+                textStyle.Size = Convert.ToString(row[2]);
+
+                if (null != row[3])
+                {
+                    int color = Convert.ToInt32(row[3]);
+
+                    textStyle.Red = color & 0xFF;
+
+                    textStyle.Green = (color & 0xFF00) >> 8;
+
+                    textStyle.Blue = (color & 0xFF0000) >> 16;
+                }
+
+                if (null != row[4])
+                {
+                    int styleBits = Convert.ToInt32(row[4]);
+
+                    if (MsiInterop.MsidbTextStyleStyleBitsBold == (styleBits & MsiInterop.MsidbTextStyleStyleBitsBold))
+                    {
+                        textStyle.Bold = Wix.YesNoType.yes;
+                    }
+
+                    if (MsiInterop.MsidbTextStyleStyleBitsItalic == (styleBits & MsiInterop.MsidbTextStyleStyleBitsItalic))
+                    {
+                        textStyle.Italic = Wix.YesNoType.yes;
+                    }
+
+                    if (MsiInterop.MsidbTextStyleStyleBitsUnderline == (styleBits & MsiInterop.MsidbTextStyleStyleBitsUnderline))
+                    {
+                        textStyle.Underline = Wix.YesNoType.yes;
+                    }
+
+                    if (MsiInterop.MsidbTextStyleStyleBitsStrike == (styleBits & MsiInterop.MsidbTextStyleStyleBitsStrike))
+                    {
+                        textStyle.Strike = Wix.YesNoType.yes;
+                    }
+                }
+
+                this.core.UIElement.AddChild(textStyle);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the TypeLib table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileTypeLibTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.TypeLib typeLib = new Wix.TypeLib();
+
+                typeLib.Id = Convert.ToString(row[0]);
+
+                typeLib.Advertise = Wix.YesNoType.yes;
+
+                typeLib.Language = Convert.ToInt32(row[1]);
+
+                if (null != row[3])
+                {
+                    int version = Convert.ToInt32(row[3]);
+
+                    if (65536 == version)
+                    {
+                        this.core.OnMessage(WixWarnings.PossiblyIncorrectTypelibVersion(row.SourceLineNumbers, typeLib.Id));
+                    }
+
+                    typeLib.MajorVersion = ((version & 0xFFFF00) >> 8);
+                    typeLib.MinorVersion = (version & 0xFF);
+                }
+
+                if (null != row[4])
+                {
+                    typeLib.Description = Convert.ToString(row[4]);
+                }
+
+                if (null != row[5])
+                {
+                    typeLib.HelpDirectory = Convert.ToString(row[5]);
+                }
+
+                if (null != row[7])
+                {
+                    typeLib.Cost = Convert.ToInt32(row[7]);
+                }
+
+                // nested under the appropriate File element in FinalizeFileTable
+                this.core.IndexElement(row, typeLib);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the Upgrade table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileUpgradeTable(Table table)
+        {
+            Hashtable upgradeElements = new Hashtable();
+
+            foreach (UpgradeRow upgradeRow in table.Rows)
+            {
+                if (Compiler.UpgradeDetectedProperty == upgradeRow.ActionProperty || Compiler.DowngradeDetectedProperty == upgradeRow.ActionProperty)
+                {
+                    continue; // MajorUpgrade rows processed in FinalizeUpgradeTable
+                }
+
+                Wix.Upgrade upgrade = (Wix.Upgrade)upgradeElements[upgradeRow.UpgradeCode];
+
+                // create the parent Upgrade element if it doesn't already exist
+                if (null == upgrade)
+                {
+                    upgrade = new Wix.Upgrade();
+
+                    upgrade.Id = upgradeRow.UpgradeCode;
+
+                    this.core.RootElement.AddChild(upgrade);
+                    upgradeElements.Add(upgrade.Id, upgrade);
+                }
+
+                Wix.UpgradeVersion upgradeVersion = new Wix.UpgradeVersion();
+
+                if (null != upgradeRow.VersionMin)
+                {
+                    upgradeVersion.Minimum = upgradeRow.VersionMin;
+                }
+
+                if (null != upgradeRow.VersionMax)
+                {
+                    upgradeVersion.Maximum = upgradeRow.VersionMax;
+                }
+
+                if (null != upgradeRow.Language)
+                {
+                    upgradeVersion.Language = upgradeRow.Language;
+                }
+
+                if (MsiInterop.MsidbUpgradeAttributesMigrateFeatures == (upgradeRow.Attributes & MsiInterop.MsidbUpgradeAttributesMigrateFeatures))
+                {
+                    upgradeVersion.MigrateFeatures = Wix.YesNoType.yes;
+                }
+
+                if (MsiInterop.MsidbUpgradeAttributesOnlyDetect == (upgradeRow.Attributes & MsiInterop.MsidbUpgradeAttributesOnlyDetect))
+                {
+                    upgradeVersion.OnlyDetect = Wix.YesNoType.yes;
+                }
+
+                if (MsiInterop.MsidbUpgradeAttributesIgnoreRemoveFailure == (upgradeRow.Attributes & MsiInterop.MsidbUpgradeAttributesIgnoreRemoveFailure))
+                {
+                    upgradeVersion.IgnoreRemoveFailure = Wix.YesNoType.yes;
+                }
+
+                if (MsiInterop.MsidbUpgradeAttributesVersionMinInclusive == (upgradeRow.Attributes & MsiInterop.MsidbUpgradeAttributesVersionMinInclusive))
+                {
+                    upgradeVersion.IncludeMinimum = Wix.YesNoType.yes;
+                }
+
+                if (MsiInterop.MsidbUpgradeAttributesVersionMaxInclusive == (upgradeRow.Attributes & MsiInterop.MsidbUpgradeAttributesVersionMaxInclusive))
+                {
+                    upgradeVersion.IncludeMaximum = Wix.YesNoType.yes;
+                }
+
+                if (MsiInterop.MsidbUpgradeAttributesLanguagesExclusive == (upgradeRow.Attributes & MsiInterop.MsidbUpgradeAttributesLanguagesExclusive))
+                {
+                    upgradeVersion.ExcludeLanguages = Wix.YesNoType.yes;
+                }
+
+                if (null != upgradeRow.Remove)
+                {
+                    upgradeVersion.RemoveFeatures = upgradeRow.Remove;
+                }
+
+                upgradeVersion.Property = upgradeRow.ActionProperty;
+
+                upgrade.AddChild(upgradeVersion);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the UpgradedFiles_OptionalData table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileUpgradedFiles_OptionalDataTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.UpgradeFile upgradeFile = new Wix.UpgradeFile();
+
+                upgradeFile.File = Convert.ToString(row[1]);
+
+                if (null != row[2])
+                {
+                    string[] symbolPaths = (Convert.ToString(row[2])).Split(';');
+
+                    foreach (string symbolPathString in symbolPaths)
+                    {
+                        Wix.SymbolPath symbolPath = new Wix.SymbolPath();
+
+                        symbolPath.Path = symbolPathString;
+
+                        upgradeFile.AddChild(symbolPath);
+                    }
+                }
+
+                if (null != row[3] && 1 == Convert.ToInt32(row[3]))
+                {
+                    upgradeFile.AllowIgnoreOnError = Wix.YesNoType.yes;
+                }
+
+                if (null != row[4] && 0 != Convert.ToInt32(row[4]))
+                {
+                    upgradeFile.WholeFile = Wix.YesNoType.yes;
+                }
+
+                upgradeFile.Ignore = Wix.YesNoType.no;
+
+                Wix.UpgradeImage upgradeImage = (Wix.UpgradeImage)this.core.GetIndexedElement("UpgradedImages", Convert.ToString(row[0]));
+                if (null != upgradeImage)
+                {
+                    upgradeImage.AddChild(upgradeFile);
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Upgraded", Convert.ToString(row[0]), "UpgradedImages"));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the UpgradedFilesToIgnore table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileUpgradedFilesToIgnoreTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                if ("*" != Convert.ToString(row[0]))
+                {
+                    Wix.UpgradeFile upgradeFile = new Wix.UpgradeFile();
+
+                    upgradeFile.File = Convert.ToString(row[1]);
+
+                    upgradeFile.Ignore = Wix.YesNoType.yes;
+
+                    Wix.UpgradeImage upgradeImage = (Wix.UpgradeImage)this.core.GetIndexedElement("UpgradedImages", Convert.ToString(row[0]));
+                    if (null != upgradeImage)
+                    {
+                        upgradeImage.AddChild(upgradeFile);
+                    }
+                    else
+                    {
+                        this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Upgraded", Convert.ToString(row[0]), "UpgradedImages"));
+                    }
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.UnrepresentableColumnValue(row.SourceLineNumbers, table.Name, row.Fields[0].Column.Name, row[0]));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the UpgradedImages table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileUpgradedImagesTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.UpgradeImage upgradeImage = new Wix.UpgradeImage();
+
+                upgradeImage.Id = Convert.ToString(row[0]);
+
+                upgradeImage.SourceFile = Convert.ToString(row[1]);
+
+                if (null != row[2])
+                {
+                    upgradeImage.SourcePatch = Convert.ToString(row[2]);
+                }
+
+                if (null != row[3])
+                {
+                    string[] symbolPaths = (Convert.ToString(row[3])).Split(';');
+
+                    foreach (string symbolPathString in symbolPaths)
+                    {
+                        Wix.SymbolPath symbolPath = new Wix.SymbolPath();
+
+                        symbolPath.Path = symbolPathString;
+
+                        upgradeImage.AddChild(symbolPath);
+                    }
+                }
+
+                Wix.Family family = (Wix.Family)this.core.GetIndexedElement("ImageFamilies", Convert.ToString(row[4]));
+                if (null != family)
+                {
+                    family.AddChild(upgradeImage);
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Family", Convert.ToString(row[4]), "ImageFamilies"));
+                }
+                this.core.IndexElement(row, upgradeImage);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the UIText table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileUITextTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.UIText uiText = new Wix.UIText();
+
+                uiText.Id = Convert.ToString(row[0]);
+
+                uiText.Content = Convert.ToString(row[1]);
+
+                this.core.UIElement.AddChild(uiText);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the Verb table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileVerbTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Wix.Verb verb = new Wix.Verb();
+
+                verb.Id = Convert.ToString(row[1]);
+
+                if (null != row[2])
+                {
+                    verb.Sequence = Convert.ToInt32(row[2]);
+                }
+
+                if (null != row[3])
+                {
+                    verb.Command = Convert.ToString(row[3]);
+                }
+
+                if (null != row[4])
+                {
+                    verb.Argument = Convert.ToString(row[4]);
+                }
+
+                this.core.IndexElement(row, verb);
+            }
+        }
+
+        /// <summary>
+        /// Gets the RegistryRootType from an integer representation of the root.
+        /// </summary>
+        /// <param name="sourceLineNumbers">The source line information for the root.</param>
+        /// <param name="tableName">The name of the table containing the field.</param>
+        /// <param name="field">The field containing the root value.</param>
+        /// <param name="registryRootType">The strongly-typed representation of the root.</param>
+        /// <returns>true if the value could be converted; false otherwise.</returns>
+        private bool GetRegistryRootType(SourceLineNumber sourceLineNumbers, string tableName, Field field, out Wix.RegistryRootType registryRootType)
+        {
+            switch (Convert.ToInt32(field.Data))
+            {
+                case (-1):
+                    registryRootType = Wix.RegistryRootType.HKMU;
+                    return true;
+                case MsiInterop.MsidbRegistryRootClassesRoot:
+                    registryRootType = Wix.RegistryRootType.HKCR;
+                    return true;
+                case MsiInterop.MsidbRegistryRootCurrentUser:
+                    registryRootType = Wix.RegistryRootType.HKCU;
+                    return true;
+                case MsiInterop.MsidbRegistryRootLocalMachine:
+                    registryRootType = Wix.RegistryRootType.HKLM;
+                    return true;
+                case MsiInterop.MsidbRegistryRootUsers:
+                    registryRootType = Wix.RegistryRootType.HKU;
+                    return true;
+                default:
+                    this.core.OnMessage(WixWarnings.IllegalColumnValue(sourceLineNumbers, tableName, field.Column.Name, field.Data));
+                    registryRootType = Wix.RegistryRootType.HKCR; // assign anything to satisfy the out parameter
+                    return false;
+            }
+        }
+
+        /// <summary>
+        /// Set the primary feature for a component.
+        /// </summary>
+        /// <param name="row">The row which specifies a primary feature.</param>
+        /// <param name="featureColumnIndex">The index of the column contaning the feature identifier.</param>
+        /// <param name="componentColumnIndex">The index of the column containing the component identifier.</param>
+        private void SetPrimaryFeature(Row row, int featureColumnIndex, int componentColumnIndex)
+        {
+            // only products contain primary features
+            if (OutputType.Product == this.outputType)
+            {
+                Field featureField = row.Fields[featureColumnIndex];
+                Field componentField = row.Fields[componentColumnIndex];
+
+                Wix.ComponentRef componentRef = (Wix.ComponentRef)this.core.GetIndexedElement("FeatureComponents", Convert.ToString(featureField.Data), Convert.ToString(componentField.Data));
+
+                if (null != componentRef)
+                {
+                    componentRef.Primary = Wix.YesNoType.yes;
+                }
+                else
+                {
+                    this.core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, row.TableDefinition.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), featureField.Column.Name, Convert.ToString(featureField.Data), componentField.Column.Name, Convert.ToString(componentField.Data), "FeatureComponents"));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Checks the InstallExecuteSequence table to determine where RemoveExistingProducts is scheduled and removes it.
+        /// </summary>
+        /// <param name="tables">The collection of all tables.</param>
+        private static Wix.MajorUpgrade.ScheduleType DetermineMajorUpgradeScheduling(TableIndexedCollection tables)
+        {
+            int sequenceRemoveExistingProducts = 0;
+            int sequenceInstallValidate = 0;
+            int sequenceInstallInitialize = 0;
+            int sequenceInstallFinalize = 0;
+            int sequenceInstallExecute = 0;
+            int sequenceInstallExecuteAgain = 0;
+
+            Table installExecuteSequenceTable = tables["InstallExecuteSequence"];
+            if (null != installExecuteSequenceTable)
+            {
+                int removeExistingProductsRow = -1;
+                for (int i = 0; i < installExecuteSequenceTable.Rows.Count; i++)
+                {
+                    Row row = installExecuteSequenceTable.Rows[i];
+                    string action = Convert.ToString(row[0]);
+                    int sequence = Convert.ToInt32(row[2]);
+
+                    switch (action)
+                    {
+                        case "RemoveExistingProducts":
+                            sequenceRemoveExistingProducts = sequence;
+                            removeExistingProductsRow = i;
+                            break;
+                        case "InstallValidate":
+                            sequenceInstallValidate = sequence;
+                            break;
+                        case "InstallInitialize":
+                            sequenceInstallInitialize = sequence;
+                            break;
+                        case "InstallExecute":
+                            sequenceInstallExecute = sequence;
+                            break;
+                        case "InstallExecuteAgain":
+                            sequenceInstallExecuteAgain = sequence;
+                            break;
+                        case "InstallFinalize":
+                            sequenceInstallFinalize = sequence;
+                            break;
+                    }
+                }
+
+                installExecuteSequenceTable.Rows.RemoveAt(removeExistingProductsRow);
+            }
+
+            if (0 != sequenceInstallValidate && sequenceInstallValidate < sequenceRemoveExistingProducts && sequenceRemoveExistingProducts < sequenceInstallInitialize)
+            {
+                return Wix.MajorUpgrade.ScheduleType.afterInstallValidate;
+            }
+            else if (0 != sequenceInstallInitialize && sequenceInstallInitialize < sequenceRemoveExistingProducts && sequenceRemoveExistingProducts < sequenceInstallExecute)
+            {
+                return Wix.MajorUpgrade.ScheduleType.afterInstallInitialize;
+            }
+            else if (0 != sequenceInstallExecute && sequenceInstallExecute < sequenceRemoveExistingProducts && sequenceRemoveExistingProducts < sequenceInstallExecuteAgain)
+            {
+                return Wix.MajorUpgrade.ScheduleType.afterInstallExecute;
+            }
+            else if (0 != sequenceInstallExecuteAgain && sequenceInstallExecuteAgain < sequenceRemoveExistingProducts && sequenceRemoveExistingProducts < sequenceInstallFinalize)
+            {
+                return Wix.MajorUpgrade.ScheduleType.afterInstallExecuteAgain;
+            }
+            else
+            {
+                return Wix.MajorUpgrade.ScheduleType.afterInstallFinalize;
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/DecompilerCore.cs b/src/WixToolset.Core/DecompilerCore.cs
new file mode 100644
index 00000000..203f2bc4
--- /dev/null
+++ b/src/WixToolset.Core/DecompilerCore.cs
@@ -0,0 +1,152 @@
+// 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
+{
+    using System;
+    using System.Collections;
+    using WixToolset.Data;
+    using WixToolset.Extensibility;
+    using Wix = WixToolset.Data.Serialize;
+
+    /// <summary>
+    /// The base of the decompiler. Holds some variables used by the decompiler and extensions,
+    /// as well as some utility methods.
+    /// </summary>
+    internal class DecompilerCore : IDecompilerCore
+    {
+        private Hashtable elements;
+        private Wix.IParentElement rootElement;
+        private bool showPedanticMessages;
+        private Wix.UI uiElement;
+
+        /// <summary>
+        /// Instantiate a new decompiler core.
+        /// </summary>
+        /// <param name="rootElement">The root element of the decompiled database.</param>
+        /// <param name="messageHandler">The message handler.</param>
+        internal DecompilerCore(Wix.IParentElement rootElement)
+        {
+            this.elements = new Hashtable();
+            this.rootElement = rootElement;
+        }
+
+        /// <summary>
+        /// Gets whether the decompiler core encountered an error while processing.
+        /// </summary>
+        /// <value>Flag if core encountered an error during processing.</value>
+        public bool EncounteredError
+        {
+            get { return Messaging.Instance.EncounteredError; }
+        }
+
+        /// <summary>
+        /// Gets the root element of the decompiled output.
+        /// </summary>
+        /// <value>The root element of the decompiled output.</value>
+        public Wix.IParentElement RootElement
+        {
+            get { return this.rootElement; }
+        }
+
+        /// <summary>
+        /// Gets or sets the option to show pedantic messages.
+        /// </summary>
+        /// <value>The option to show pedantic messages.</value>
+        public bool ShowPedanticMessages
+        {
+            get { return this.showPedanticMessages; }
+            set { this.showPedanticMessages = value; }
+        }
+
+        /// <summary>
+        /// Gets the UI element.
+        /// </summary>
+        /// <value>The UI element.</value>
+        public Wix.UI UIElement
+        {
+            get
+            {
+                if (null == this.uiElement)
+                {
+                    this.uiElement = new Wix.UI();
+                    this.rootElement.AddChild(this.uiElement);
+                }
+
+                return this.uiElement;
+            }
+        }
+
+        /// <summary>
+        /// Verifies if a filename is a valid short filename.
+        /// </summary>
+        /// <param name="filename">Filename to verify.</param>
+        /// <param name="allowWildcards">true if wildcards are allowed in the filename.</param>
+        /// <returns>True if the filename is a valid short filename</returns>
+        public virtual bool IsValidShortFilename(string filename, bool allowWildcards)
+        {
+            return false;
+        }
+
+        /// <summary>
+        /// Convert an Int32 into a DateTime.
+        /// </summary>
+        /// <param name="value">The Int32 value.</param>
+        /// <returns>The DateTime.</returns>
+        public DateTime ConvertIntegerToDateTime(int value)
+        {
+            int date = value / 65536;
+            int time = value % 65536;
+
+            return new DateTime(1980 + (date / 512), (date % 512) / 32, date % 32, time / 2048, (time % 2048) / 32, (time % 32) * 2);
+        }
+
+        /// <summary>
+        /// Gets the element corresponding to the row it came from.
+        /// </summary>
+        /// <param name="row">The row corresponding to the element.</param>
+        /// <returns>The indexed element.</returns>
+        public Wix.ISchemaElement GetIndexedElement(Row row)
+        {
+            return this.GetIndexedElement(row.TableDefinition.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter));
+        }
+
+        /// <summary>
+        /// Gets the element corresponding to the primary key of the given table.
+        /// </summary>
+        /// <param name="table">The table corresponding to the element.</param>
+        /// <param name="primaryKey">The primary key corresponding to the element.</param>
+        /// <returns>The indexed element.</returns>
+        public Wix.ISchemaElement GetIndexedElement(string table, params string[] primaryKey)
+        {
+            return (Wix.ISchemaElement)this.elements[String.Concat(table, ':', String.Join(DecompilerConstants.PrimaryKeyDelimiterString, primaryKey))];
+        }
+
+        /// <summary>
+        /// Index an element by its corresponding row.
+        /// </summary>
+        /// <param name="row">The row corresponding to the element.</param>
+        /// <param name="element">The element to index.</param>
+        public void IndexElement(Row row, Wix.ISchemaElement element)
+        {
+            this.elements.Add(String.Concat(row.TableDefinition.Name, ':', row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter)), element);
+        }
+
+        /// <summary>
+        /// Indicates the decompiler encountered and unexpected table to decompile.
+        /// </summary>
+        /// <param name="table">Unknown decompiled table.</param>
+        public void UnexpectedTable(Table table)
+        {
+            this.OnMessage(WixErrors.TableDecompilationUnimplemented(table.Name));
+        }
+
+        /// <summary>
+        /// Sends a message to the message delegate if there is one.
+        /// </summary>
+        /// <param name="mea">Message event arguments.</param>
+        public void OnMessage(MessageEventArgs e)
+        {
+            Messaging.Instance.OnMessage(e);
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Differ.cs b/src/WixToolset.Core/Differ.cs
new file mode 100644
index 00000000..71a64327
--- /dev/null
+++ b/src/WixToolset.Core/Differ.cs
@@ -0,0 +1,621 @@
+// 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
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+    using WixToolset.Extensibility;
+    using WixToolset.Msi;
+
+    /// <summary>
+    /// Creates a transform by diffing two outputs.
+    /// </summary>
+    public sealed class Differ : IMessageHandler
+    {
+        private List<IInspectorExtension> inspectorExtensions;
+        private bool showPedanticMessages;
+        private bool suppressKeepingSpecialRows;
+        private bool preserveUnchangedRows;
+        private const char sectionDelimiter = '/';
+        private SummaryInformationStreams transformSummaryInfo;
+
+        /// <summary>
+        /// Instantiates a new Differ class.
+        /// </summary>
+        public Differ()
+        {
+            this.inspectorExtensions = new List<IInspectorExtension>();
+        }
+
+        /// <summary>
+        /// Gets or sets the option to show pedantic messages.
+        /// </summary>
+        /// <value>The option to show pedantic messages.</value>
+        public bool ShowPedanticMessages
+        {
+            get { return this.showPedanticMessages; }
+            set { this.showPedanticMessages = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the option to suppress keeping special rows.
+        /// </summary>
+        /// <value>The option to suppress keeping special rows.</value>
+        public bool SuppressKeepingSpecialRows
+        {
+            get { return this.suppressKeepingSpecialRows; }
+            set { this.suppressKeepingSpecialRows = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the flag to determine if all rows, even unchanged ones will be persisted in the output.
+        /// </summary>
+        /// <value>The option to keep all rows including unchanged rows.</value>
+        public bool PreserveUnchangedRows
+        {
+            get { return this.preserveUnchangedRows; }
+            set { this.preserveUnchangedRows = value; }
+        }
+
+        /// <summary>
+        /// Adds an extension.
+        /// </summary>
+        /// <param name="extension">The extension to add.</param>
+        public void AddExtension(IInspectorExtension extension)
+        {
+            this.inspectorExtensions.Add(extension);
+        }
+
+        /// <summary>
+        /// Creates a transform by diffing two outputs.
+        /// </summary>
+        /// <param name="targetOutput">The target output.</param>
+        /// <param name="updatedOutput">The updated output.</param>
+        /// <returns>The transform.</returns>
+        public Output Diff(Output targetOutput, Output updatedOutput)
+        {
+            return Diff(targetOutput, updatedOutput, 0);
+        }
+
+        /// <summary>
+        /// Creates a transform by diffing two outputs.
+        /// </summary>
+        /// <param name="targetOutput">The target output.</param>
+        /// <param name="updatedOutput">The updated output.</param>
+        /// <param name="validationFlags"></param>
+        /// <returns>The transform.</returns>
+        public Output Diff(Output targetOutput, Output updatedOutput, TransformFlags validationFlags)
+        {
+            Output transform = new Output(null);
+            transform.Type = OutputType.Transform;
+            transform.Codepage = updatedOutput.Codepage;
+            this.transformSummaryInfo = new SummaryInformationStreams();
+
+            // compare the codepages
+            if (targetOutput.Codepage != updatedOutput.Codepage && 0 == (TransformFlags.ErrorChangeCodePage & validationFlags))
+            {
+                this.OnMessage(WixErrors.OutputCodepageMismatch(targetOutput.SourceLineNumbers, targetOutput.Codepage, updatedOutput.Codepage));
+                if (null != updatedOutput.SourceLineNumbers)
+                {
+                    this.OnMessage(WixErrors.OutputCodepageMismatch2(updatedOutput.SourceLineNumbers));
+                }
+            }
+
+            // compare the output types
+            if (targetOutput.Type != updatedOutput.Type)
+            {
+                throw new WixException(WixErrors.OutputTypeMismatch(targetOutput.SourceLineNumbers, targetOutput.Type.ToString(), updatedOutput.Type.ToString()));
+            }
+
+            // compare the contents of the tables
+            foreach (Table targetTable in targetOutput.Tables)
+            {
+                Table updatedTable = updatedOutput.Tables[targetTable.Name];
+                TableOperation operation = TableOperation.None;
+
+                List<Row> rows = this.CompareTables(targetOutput, targetTable, updatedTable, out operation);
+
+                if (TableOperation.Drop == operation)
+                {
+                    Table droppedTable = transform.EnsureTable(targetTable.Definition);
+                    droppedTable.Operation = TableOperation.Drop;
+                }
+                else if (TableOperation.None == operation)
+                {
+                    Table modified = transform.EnsureTable(updatedTable.Definition);
+                    rows.ForEach(r => modified.Rows.Add(r));
+                }
+            }
+
+            // added tables
+            foreach (Table updatedTable in updatedOutput.Tables)
+            {
+                if (null == targetOutput.Tables[updatedTable.Name])
+                {
+                    Table addedTable = transform.EnsureTable(updatedTable.Definition);
+                    addedTable.Operation = TableOperation.Add;
+
+                    foreach (Row updatedRow in updatedTable.Rows)
+                    {
+                        updatedRow.Operation = RowOperation.Add;
+                        updatedRow.SectionId = sectionDelimiter + updatedRow.SectionId;
+                        addedTable.Rows.Add(updatedRow);
+                    }
+                }
+            }
+
+            // set summary information properties
+            if (!this.suppressKeepingSpecialRows)
+            {
+                Table summaryInfoTable = transform.Tables["_SummaryInformation"];
+                this.UpdateTransformSummaryInformationTable(summaryInfoTable, validationFlags);
+            }
+
+            // inspect the transform
+            InspectorCore inspectorCore = new InspectorCore();
+            foreach (InspectorExtension inspectorExtension in this.inspectorExtensions)
+            {
+                inspectorExtension.Core = inspectorCore;
+                inspectorExtension.InspectOutput(transform);
+
+                // reset
+                inspectorExtension.Core = null;
+            }
+
+            return transform;
+        }
+
+        /// <summary>
+        /// Sends a message to the message delegate if there is one.
+        /// </summary>
+        /// <param name="mea">Message event arguments.</param>
+        public void OnMessage(MessageEventArgs e)
+        {
+            Messaging.Instance.OnMessage(e);
+        }
+
+        /// <summary>
+        /// Add a row to the <paramref name="index"/> using the primary key.
+        /// </summary>
+        /// <param name="index">The indexed rows.</param>
+        /// <param name="row">The row to index.</param>
+        private void AddIndexedRow(IDictionary index, Row row)
+        {
+            string primaryKey = row.GetPrimaryKey('/');
+            if (null != primaryKey)
+            {
+                // Overriding WixActionRows have a primary key defined and take precedence in the index.
+                if (row is WixActionRow)
+                {
+                    WixActionRow currentRow = (WixActionRow)row;
+                    if (index.Contains(primaryKey))
+                    {
+                        // If the current row is not overridable, see if the indexed row is.
+                        if (!currentRow.Overridable)
+                        {
+                            WixActionRow indexedRow = index[primaryKey] as WixActionRow;
+                            if (null != indexedRow && indexedRow.Overridable)
+                            {
+                                // The indexed key is overridable and should be replaced
+                                // (not removed and re-added which results in two Array.Copy
+                                // operations for SortedList, or may be re-hashing in other
+                                // implementations of IDictionary).
+                                index[primaryKey] = currentRow;
+                            }
+                        }
+
+                        // If we got this far, the row does not need to be indexed.
+                        return;
+                    }
+                }
+
+                // Nothing else should be added more than once.
+                if (!index.Contains(primaryKey))
+                {
+                    index.Add(primaryKey, row);
+                }
+                else if (this.showPedanticMessages)
+                {
+                    this.OnMessage(WixWarnings.DuplicatePrimaryKey(row.SourceLineNumbers, primaryKey, row.Table.Name));
+                }
+            }
+            else // use the string representation of the row as its primary key (it may not be unique)
+            {
+                // this is provided for compatibility with unreal tables with no primary key
+                // all real tables must specify at least one column as the primary key
+                primaryKey = row.ToString();
+                index[primaryKey] = row;
+            }
+        }
+
+        private Row CompareRows(Table targetTable, Row targetRow, Row updatedRow, out RowOperation operation, out bool keepRow)
+        {
+            Row comparedRow = null;
+            keepRow = false;
+            operation = RowOperation.None;
+
+            if (null == targetRow ^ null == updatedRow)
+            {
+                if (null == targetRow)
+                {
+                    operation = updatedRow.Operation = RowOperation.Add;
+                    comparedRow = updatedRow;
+                }
+                else if (null == updatedRow)
+                {
+                    operation = targetRow.Operation = RowOperation.Delete;
+                    targetRow.SectionId = targetRow.SectionId + sectionDelimiter;
+                    comparedRow = targetRow;
+                    keepRow = true;
+                }
+            }
+            else // possibly modified
+            {
+                updatedRow.Operation = RowOperation.None;
+                if (!this.suppressKeepingSpecialRows && "_SummaryInformation" == targetTable.Name)
+                {
+                    // ignore rows that shouldn't be in a transform
+                    if (Enum.IsDefined(typeof(SummaryInformation.Transform), (int)updatedRow[0]))
+                    {
+                        updatedRow.SectionId = targetRow.SectionId + sectionDelimiter + updatedRow.SectionId;
+                        comparedRow = updatedRow;
+                        keepRow = true;
+                        operation = RowOperation.Modify;
+                    }
+                }
+                else
+                {
+                    if (this.preserveUnchangedRows)
+                    {
+                        keepRow = true;
+                    }
+
+                    for (int i = 0; i < updatedRow.Fields.Length; i++)
+                    {
+                        ColumnDefinition columnDefinition = updatedRow.Fields[i].Column;
+
+                        if (!columnDefinition.PrimaryKey)
+                        {
+                            bool modified = false;
+
+                            if (i >= targetRow.Fields.Length)
+                            {
+                                columnDefinition.Added = true;
+                                modified = true;
+                            }
+                            else if (ColumnType.Number == columnDefinition.Type && !columnDefinition.IsLocalizable)
+                            {
+                                if (null == targetRow[i] ^ null == updatedRow[i])
+                                {
+                                    modified = true;
+                                }
+                                else if (null != targetRow[i] && null != updatedRow[i])
+                                {
+                                    modified = ((int)targetRow[i] != (int)updatedRow[i]);
+                                }
+                            }
+                            else if (ColumnType.Preserved == columnDefinition.Type)
+                            {
+                                updatedRow.Fields[i].PreviousData = (string)targetRow.Fields[i].Data;
+
+                                // keep rows containing preserved fields so the historical data is available to the binder
+                                keepRow = !this.suppressKeepingSpecialRows;
+                            }
+                            else if (ColumnType.Object == columnDefinition.Type)
+                            {
+                                ObjectField targetObjectField = (ObjectField)targetRow.Fields[i];
+                                ObjectField updatedObjectField = (ObjectField)updatedRow.Fields[i];
+
+                                updatedObjectField.PreviousEmbeddedFileIndex = targetObjectField.EmbeddedFileIndex;
+                                updatedObjectField.PreviousBaseUri = targetObjectField.BaseUri;
+
+                                // always keep a copy of the previous data even if they are identical
+                                // This makes diff.wixmst clean and easier to control patch logic
+                                updatedObjectField.PreviousData = (string)targetObjectField.Data;
+
+                                // always remember the unresolved data for target build
+                                updatedObjectField.UnresolvedPreviousData = (string)targetObjectField.UnresolvedData;
+
+                                // keep rows containing object fields so the files can be compared in the binder
+                                keepRow = !this.suppressKeepingSpecialRows;
+                            }
+                            else
+                            {
+                                modified = ((string)targetRow[i] != (string)updatedRow[i]);
+                            }
+
+                            if (modified)
+                            {
+                                if (null != updatedRow.Fields[i].PreviousData)
+                                {
+                                    updatedRow.Fields[i].PreviousData = targetRow.Fields[i].Data.ToString();
+                                }
+
+                                updatedRow.Fields[i].Modified = true;
+                                operation = updatedRow.Operation = RowOperation.Modify;
+                                keepRow = true;
+                            }
+                        }
+                    }
+
+                    if (keepRow)
+                    {
+                        comparedRow = updatedRow;
+                        comparedRow.SectionId = targetRow.SectionId + sectionDelimiter + updatedRow.SectionId;
+                    }
+                }
+            }
+
+            return comparedRow;
+        }
+
+        private List<Row> CompareTables(Output targetOutput, Table targetTable, Table updatedTable, out TableOperation operation)
+        {
+            List<Row> rows = new List<Row>();
+            operation = TableOperation.None;
+
+            // dropped tables
+            if (null == updatedTable ^ null == targetTable)
+            {
+                if (null == targetTable)
+                {
+                    operation = TableOperation.Add;
+                    rows.AddRange(updatedTable.Rows);
+                }
+                else if (null == updatedTable)
+                {
+                    operation = TableOperation.Drop;
+                }
+            }
+            else // possibly modified tables
+            {
+                SortedList updatedPrimaryKeys = new SortedList();
+                SortedList targetPrimaryKeys = new SortedList();
+
+                // compare the table definitions
+                if (0 != targetTable.Definition.CompareTo(updatedTable.Definition))
+                {
+                    // continue to the next table; may be more mismatches
+                    this.OnMessage(WixErrors.DatabaseSchemaMismatch(targetOutput.SourceLineNumbers, targetTable.Name));
+                }
+                else
+                {
+                    this.IndexPrimaryKeys(targetTable, targetPrimaryKeys, updatedTable, updatedPrimaryKeys);
+
+                    // diff the target and updated rows
+                    foreach (DictionaryEntry targetPrimaryKeyEntry in targetPrimaryKeys)
+                    {
+                        string targetPrimaryKey = (string)targetPrimaryKeyEntry.Key;
+                        bool keepRow = false;
+                        RowOperation rowOperation = RowOperation.None;
+
+                        Row compared = this.CompareRows(targetTable, targetPrimaryKeyEntry.Value as Row, updatedPrimaryKeys[targetPrimaryKey] as Row, out rowOperation, out keepRow);
+
+                        if (keepRow)
+                        {
+                            rows.Add(compared);
+                        }
+                    }
+
+                    // find the inserted rows
+                    foreach (DictionaryEntry updatedPrimaryKeyEntry in updatedPrimaryKeys)
+                    {
+                        string updatedPrimaryKey = (string)updatedPrimaryKeyEntry.Key;
+
+                        if (!targetPrimaryKeys.Contains(updatedPrimaryKey))
+                        {
+                            Row updatedRow = (Row)updatedPrimaryKeyEntry.Value;
+
+                            updatedRow.Operation = RowOperation.Add;
+                            updatedRow.SectionId = sectionDelimiter + updatedRow.SectionId;
+                            rows.Add(updatedRow);
+                        }
+                    }
+                }
+            }
+
+            return rows;
+        }
+
+        private void IndexPrimaryKeys(Table targetTable, SortedList targetPrimaryKeys, Table updatedTable, SortedList updatedPrimaryKeys)
+        {
+            // index the target rows
+            foreach (Row row in targetTable.Rows)
+            {
+                this.AddIndexedRow(targetPrimaryKeys, row);
+
+                if ("Property" == targetTable.Name)
+                {
+                    if ("ProductCode" == (string)row[0])
+                    {
+                        this.transformSummaryInfo.TargetProductCode = (string)row[1];
+                        if ("*" == this.transformSummaryInfo.TargetProductCode)
+                        {
+                            this.OnMessage(WixErrors.ProductCodeInvalidForTransform(row.SourceLineNumbers));
+                        }
+                    }
+                    else if ("ProductVersion" == (string)row[0])
+                    {
+                        this.transformSummaryInfo.TargetProductVersion = (string)row[1];
+                    }
+                    else if ("UpgradeCode" == (string)row[0])
+                    {
+                        this.transformSummaryInfo.TargetUpgradeCode = (string)row[1];
+                    }
+                }
+                else if ("_SummaryInformation" == targetTable.Name)
+                {
+                    if (1 == (int)row[0]) // PID_CODEPAGE
+                    {
+                        this.transformSummaryInfo.TargetSummaryInfoCodepage = (string)row[1];
+                    }
+                    else if (7 == (int)row[0]) // PID_TEMPLATE
+                    {
+                        this.transformSummaryInfo.TargetPlatformAndLanguage = (string)row[1];
+                    }
+                    else if (14 == (int)row[0]) // PID_PAGECOUNT
+                    {
+                        this.transformSummaryInfo.TargetMinimumVersion = (string)row[1];
+                    }
+                }
+            }
+
+            // index the updated rows
+            foreach (Row row in updatedTable.Rows)
+            {
+                this.AddIndexedRow(updatedPrimaryKeys, row);
+
+                if ("Property" == updatedTable.Name)
+                {
+                    if ("ProductCode" == (string)row[0])
+                    {
+                        this.transformSummaryInfo.UpdatedProductCode = (string)row[1];
+                        if ("*" == this.transformSummaryInfo.UpdatedProductCode)
+                        {
+                            this.OnMessage(WixErrors.ProductCodeInvalidForTransform(row.SourceLineNumbers));
+                        }
+                    }
+                    else if ("ProductVersion" == (string)row[0])
+                    {
+                        this.transformSummaryInfo.UpdatedProductVersion = (string)row[1];
+                    }
+                }
+                else if ("_SummaryInformation" == updatedTable.Name)
+                {
+                    if (1 == (int)row[0]) // PID_CODEPAGE
+                    {
+                        this.transformSummaryInfo.UpdatedSummaryInfoCodepage = (string)row[1];
+                    }
+                    else if (7 == (int)row[0]) // PID_TEMPLATE
+                    {
+                        this.transformSummaryInfo.UpdatedPlatformAndLanguage = (string)row[1];
+                    }
+                    else if (14 == (int)row[0]) // PID_PAGECOUNT
+                    {
+                        this.transformSummaryInfo.UpdatedMinimumVersion = (string)row[1];
+                    }
+                }
+            }
+        }
+
+        private void UpdateTransformSummaryInformationTable(Table summaryInfoTable, TransformFlags validationFlags)
+        {
+            // calculate the minimum version of MSI required to process the transform
+            int targetMin;
+            int updatedMin;
+            int minimumVersion = 100;
+
+            if (Int32.TryParse(this.transformSummaryInfo.TargetMinimumVersion, out targetMin) && Int32.TryParse(this.transformSummaryInfo.UpdatedMinimumVersion, out updatedMin))
+            {
+                minimumVersion = Math.Max(targetMin, updatedMin);
+            }
+
+            Hashtable summaryRows = new Hashtable(summaryInfoTable.Rows.Count);
+            foreach (Row row in summaryInfoTable.Rows)
+            {
+                summaryRows[row[0]] = row;
+
+                if ((int)SummaryInformation.Transform.CodePage == (int)row[0])
+                {
+                    row.Fields[1].Data = this.transformSummaryInfo.UpdatedSummaryInfoCodepage;
+                    row.Fields[1].PreviousData = this.transformSummaryInfo.TargetSummaryInfoCodepage;
+                }
+                else if ((int)SummaryInformation.Transform.TargetPlatformAndLanguage == (int)row[0])
+                {
+                    row[1] = this.transformSummaryInfo.TargetPlatformAndLanguage;
+                }
+                else if ((int)SummaryInformation.Transform.UpdatedPlatformAndLanguage == (int)row[0])
+                {
+                    row[1] = this.transformSummaryInfo.UpdatedPlatformAndLanguage;
+                }
+                else if ((int)SummaryInformation.Transform.ProductCodes == (int)row[0])
+                {
+                    row[1] = String.Concat(this.transformSummaryInfo.TargetProductCode, this.transformSummaryInfo.TargetProductVersion, ';', this.transformSummaryInfo.UpdatedProductCode, this.transformSummaryInfo.UpdatedProductVersion, ';', this.transformSummaryInfo.TargetUpgradeCode);
+                }
+                else if ((int)SummaryInformation.Transform.InstallerRequirement == (int)row[0])
+                {
+                    row[1] = minimumVersion.ToString(CultureInfo.InvariantCulture);
+                }
+                else if ((int)SummaryInformation.Transform.Security == (int)row[0])
+                {
+                    row[1] = "4";
+                }
+            }
+
+            if (!summaryRows.Contains((int)SummaryInformation.Transform.TargetPlatformAndLanguage))
+            {
+                Row summaryRow = summaryInfoTable.CreateRow(null);
+                summaryRow[0] = (int)SummaryInformation.Transform.TargetPlatformAndLanguage;
+                summaryRow[1] = this.transformSummaryInfo.TargetPlatformAndLanguage;
+            }
+
+            if (!summaryRows.Contains((int)SummaryInformation.Transform.UpdatedPlatformAndLanguage))
+            {
+                Row summaryRow = summaryInfoTable.CreateRow(null);
+                summaryRow[0] = (int)SummaryInformation.Transform.UpdatedPlatformAndLanguage;
+                summaryRow[1] = this.transformSummaryInfo.UpdatedPlatformAndLanguage;
+            }
+
+            if (!summaryRows.Contains((int)SummaryInformation.Transform.ValidationFlags))
+            {
+                Row summaryRow = summaryInfoTable.CreateRow(null);
+                summaryRow[0] = (int)SummaryInformation.Transform.ValidationFlags;
+                summaryRow[1] = ((int)validationFlags).ToString(CultureInfo.InvariantCulture);
+            }
+
+            if (!summaryRows.Contains((int)SummaryInformation.Transform.InstallerRequirement))
+            {
+                Row summaryRow = summaryInfoTable.CreateRow(null);
+                summaryRow[0] = (int)SummaryInformation.Transform.InstallerRequirement;
+                summaryRow[1] = minimumVersion.ToString(CultureInfo.InvariantCulture);
+            }
+
+            if (!summaryRows.Contains((int)SummaryInformation.Transform.Security))
+            {
+                Row summaryRow = summaryInfoTable.CreateRow(null);
+                summaryRow[0] = (int)SummaryInformation.Transform.Security;
+                summaryRow[1] = "4";
+            }
+        }
+
+        private class SummaryInformationStreams
+        {
+            public string TargetSummaryInfoCodepage
+            { get; set; }
+
+            public string TargetPlatformAndLanguage
+            { get; set; }
+
+            public string TargetProductCode
+            { get; set; }
+
+            public string TargetProductVersion
+            { get; set; }
+
+            public string TargetUpgradeCode
+            { get; set; }
+
+            public string TargetMinimumVersion
+            { get; set; }
+
+            public string UpdatedSummaryInfoCodepage
+            { get; set; }
+
+            public string UpdatedPlatformAndLanguage
+            { get; set; }
+
+            public string UpdatedProductCode
+            { get; set; }
+
+            public string UpdatedProductVersion
+            { get; set; }
+
+            public string UpdatedMinimumVersion
+            { get; set; }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Exceptions/WixFileNotFoundException.cs b/src/WixToolset.Core/Exceptions/WixFileNotFoundException.cs
new file mode 100644
index 00000000..14169c4c
--- /dev/null
+++ b/src/WixToolset.Core/Exceptions/WixFileNotFoundException.cs
@@ -0,0 +1,52 @@
+// 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
+{
+    using System;
+    using WixToolset.Data;
+
+    /// <summary>
+    /// WixException thrown when a file cannot be found.
+    /// </summary>
+    [Serializable]
+    public sealed class WixFileNotFoundException : WixException
+    {
+        /// <summary>
+        /// Instantiate a new WixFileNotFoundException.
+        /// </summary>
+        /// <param name="file">The file that could not be found.</param>
+        public WixFileNotFoundException(string file) : this(null, file, null)
+        {
+        }
+
+        /// <summary>
+        /// Instantiate a new WixFileNotFoundException.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information pertaining to the file that cannot be found.</param>
+        /// <param name="file">The file that could not be found.</param>
+        public WixFileNotFoundException(SourceLineNumber sourceLineNumbers, string file) :
+            base(WixErrors.FileNotFound(sourceLineNumbers, file))
+        {
+        }
+
+        /// <summary>
+        /// Instantiate a new WixFileNotFoundException.
+        /// </summary>
+        /// <param name="file">The file that could not be found.</param>
+        /// <param name="fileType">The type of file that cannot be found.</param>
+        public WixFileNotFoundException(string file, string fileType) : this(null, file, fileType)
+        {
+        }
+
+        /// <summary>
+        /// Instantiate a new WixFileNotFoundException.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information pertaining to the file that cannot be found.</param>
+        /// <param name="file">The file that could not be found.</param>
+        /// <param name="fileType">The type of file that cannot be found.</param>
+        public WixFileNotFoundException(SourceLineNumber sourceLineNumbers, string file, string fileType) :
+            base(WixErrors.FileNotFound(sourceLineNumbers, file, fileType))
+        {
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Extensibility/AssemblyDefaultHeatExtensionAttribute.cs b/src/WixToolset.Core/Extensibility/AssemblyDefaultHeatExtensionAttribute.cs
new file mode 100644
index 00000000..bb53e30c
--- /dev/null
+++ b/src/WixToolset.Core/Extensibility/AssemblyDefaultHeatExtensionAttribute.cs
@@ -0,0 +1,33 @@
+// 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.Tools
+{
+    using System;
+
+    /// <summary>
+    /// Represents a custom attribute for declaring the type to use
+    /// as the default heat extension in an assembly.
+    /// </summary>
+    public class AssemblyDefaultHeatExtensionAttribute : Attribute
+    {
+        private readonly Type extensionType;
+
+        /// <summary>
+        /// Instantiate a new AssemblyDefaultHeatExtensionAttribute.
+        /// </summary>
+        /// <param name="extensionType">The type of the default heat extension in an assembly.</param>
+        public AssemblyDefaultHeatExtensionAttribute(Type extensionType)
+        {
+            this.extensionType = extensionType;
+        }
+
+        /// <summary>
+        /// Gets the type of the default heat extension in an assembly.
+        /// </summary>
+        /// <value>The type of the default heat extension in an assembly.</value>
+        public Type ExtensionType
+        {
+            get { return this.extensionType; }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Extensibility/HarvesterExtension.cs b/src/WixToolset.Core/Extensibility/HarvesterExtension.cs
new file mode 100644
index 00000000..d8d0ab34
--- /dev/null
+++ b/src/WixToolset.Core/Extensibility/HarvesterExtension.cs
@@ -0,0 +1,26 @@
+// 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
+{
+    using Wix = WixToolset.Data.Serialize;
+
+    /// <summary>
+    /// The base harvester extension.  Any of these methods can be overridden to change
+    /// the behavior of the harvester.
+    /// </summary>
+    public abstract class HarvesterExtension
+    {
+        /// <summary>
+        /// Gets or sets the harvester core for the extension.
+        /// </summary>
+        /// <value>The harvester core for the extension.</value>
+        public IHarvesterCore Core { get; set; }
+
+        /// <summary>
+        /// Harvest a WiX document.
+        /// </summary>
+        /// <param name="argument">The argument for harvesting.</param>
+        /// <returns>The harvested Fragments.</returns>
+        public abstract Wix.Fragment[] Harvest(string argument);
+    }
+}
diff --git a/src/WixToolset.Core/Extensibility/HeatExtension.cs b/src/WixToolset.Core/Extensibility/HeatExtension.cs
new file mode 100644
index 00000000..5e292220
--- /dev/null
+++ b/src/WixToolset.Core/Extensibility/HeatExtension.cs
@@ -0,0 +1,204 @@
+// 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.Extensibility
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Reflection;
+    using WixToolset;
+    using WixToolset.Data;
+    using WixToolset.Extensibilty;
+    using WixToolset.Tools;
+    using Wix = WixToolset.Data.Serialize;
+
+    /// <summary>
+    /// A command line option.
+    /// </summary>
+    public struct HeatCommandLineOption
+    {
+        public string Option;
+
+        public string Description;
+
+        /// <summary>
+        /// Instantiates a new CommandLineOption.
+        /// </summary>
+        /// <param name="option">The option name.</param>
+        /// <param name="description">The description of the option.</param>
+        public HeatCommandLineOption(string option, string description)
+        {
+            this.Option = option;
+            this.Description = description;
+        }
+    }
+
+    /// <summary>
+    /// An extension for the WiX Toolset Harvester application.
+    /// </summary>
+    public abstract class HeatExtension
+    {
+        /// <summary>
+        /// Gets or sets the heat core for the extension.
+        /// </summary>
+        /// <value>The heat core for the extension.</value>
+        public IHeatCore Core { get; set; }
+
+        /// <summary>
+        /// Gets the supported command line types for this extension.
+        /// </summary>
+        /// <value>The supported command line types for this extension.</value>
+        public virtual HeatCommandLineOption[] CommandLineTypes
+        {
+            get { return null; }
+        }
+
+        /// <summary>
+        /// Loads a HeatExtension from a type description string.
+        /// </summary>
+        /// <param name="extension">The extension type description string.</param>
+        /// <returns>The loaded HeatExtension.</returns>
+        /// <remarks>
+        /// <paramref name="extension"/> can be in several different forms:
+        /// <list type="number">
+        /// <item><term>AssemblyQualifiedName (TopNamespace.SubNameSpace.ContainingClass+NestedClass, MyAssembly, Version=1.3.0.0, Culture=neutral, PublicKeyToken=b17a5c561934e089)</term></item>
+        /// <item><term>AssemblyName (MyAssembly, Version=1.3.0.0, Culture=neutral, PublicKeyToken=b17a5c561934e089)</term></item>
+        /// <item><term>Absolute path to an assembly (C:\MyExtensions\ExtensionAssembly.dll)</term></item>
+        /// <item><term>Filename of an assembly in the application directory (ExtensionAssembly.dll)</term></item>
+        /// <item><term>Relative path to an assembly (..\..\MyExtensions\ExtensionAssembly.dll)</term></item>
+        /// </list>
+        /// To specify a particular class to use, prefix the fully qualified class name to the assembly and separate them with a comma.
+        /// For example: "TopNamespace.SubNameSpace.ContainingClass+NestedClass, C:\MyExtensions\ExtensionAssembly.dll"
+        /// </remarks>
+        public static HeatExtension Load(string extension)
+        {
+            Type extensionType = null;
+            int commaIndex = extension.IndexOf(',');
+            string className = String.Empty;
+            string assemblyName = extension;
+
+            if (0 <= commaIndex)
+            {
+                className = extension.Substring(0, commaIndex);
+                assemblyName = (extension.Length <= commaIndex + 1 ? String.Empty : extension.Substring(commaIndex + 1));
+            }
+
+            className = className.Trim();
+            assemblyName = assemblyName.Trim();
+
+            if (null == extensionType && 0 < assemblyName.Length)
+            {
+
+                Assembly extensionAssembly;
+
+                // case 3: Absolute path to an assembly
+                if (Path.IsPathRooted(assemblyName))
+                {
+                    extensionAssembly = ExtensionLoadFrom(assemblyName);
+                }
+                else
+                {
+                    try
+                    {
+                        // case 2: AssemblyName
+                        extensionAssembly = Assembly.Load(assemblyName);
+                    }
+                    catch (IOException e)
+                    {
+                        if (e is FileLoadException || e is FileNotFoundException)
+                        {
+                            try
+                            {
+                                // case 4: Filename of an assembly in the application directory
+                                extensionAssembly = Assembly.Load(Path.GetFileNameWithoutExtension(assemblyName));
+                            }
+                            catch (IOException innerE)
+                            {
+                                if (innerE is FileLoadException || innerE is FileNotFoundException)
+                                {
+                                    // case 5: Relative path to an assembly
+
+                                    // we want to use Assembly.Load when we can because it has some benefits over Assembly.LoadFrom
+                                    // (see the documentation for Assembly.LoadFrom). However, it may fail when the path is a relative
+                                    // path, so we should try Assembly.LoadFrom one last time. We could have detected a directory
+                                    // separator character and used Assembly.LoadFrom directly, but dealing with path canonicalization
+                                    // issues is something we don't want to deal with if we don't have to.
+                                    extensionAssembly = ExtensionLoadFrom(assemblyName);
+                                }
+                                else
+                                {
+                                    throw new WixException(WixErrors.InvalidExtension(assemblyName, innerE.Message));
+                                }
+                            }
+                        }
+                        else
+                        {
+                            throw new WixException(WixErrors.InvalidExtension(assemblyName, e.Message));
+                        }
+                    }
+                }
+
+                if (0 < className.Length)
+                {
+                    try
+                    {
+                        // case 1: AssemblyQualifiedName
+                        extensionType = extensionAssembly.GetType(className, true /* throwOnError */, true /* ignoreCase */);
+                    }
+                    catch (Exception e)
+                    {
+                        throw new WixException(WixErrors.InvalidExtensionType(assemblyName, className, e.GetType().ToString(), e.Message));
+                    }
+                }
+                else
+                {
+                    // if no class name was specified, then let's hope the assembly defined a default WixExtension
+                    AssemblyDefaultHeatExtensionAttribute extensionAttribute = (AssemblyDefaultHeatExtensionAttribute)Attribute.GetCustomAttribute(extensionAssembly, typeof(AssemblyDefaultHeatExtensionAttribute));
+
+                    if (null != extensionAttribute)
+                    {
+                        extensionType = extensionAttribute.ExtensionType;
+                    }
+                    else
+                    {
+                        throw new WixException(WixErrors.InvalidExtensionType(assemblyName, typeof(AssemblyDefaultHeatExtensionAttribute).ToString()));
+                    }
+                }
+            }
+
+            if (extensionType.IsSubclassOf(typeof(HeatExtension)))
+            {
+                return Activator.CreateInstance(extensionType) as HeatExtension;
+            }
+            else
+            {
+                throw new WixException(WixErrors.InvalidExtensionType(extension, extensionType.ToString(), typeof(HeatExtension).ToString()));
+            }
+        }
+
+        /// <summary>
+        /// Parse the command line options for this extension.
+        /// </summary>
+        /// <param name="type">The active harvester type.</param>
+        /// <param name="args">The option arguments.</param>
+        public virtual void ParseOptions(string type, string[] args)
+        {
+        }
+
+        private static Assembly ExtensionLoadFrom(string assemblyName)
+        {
+            Assembly extensionAssembly = null;
+
+            try
+            {
+                extensionAssembly = Assembly.LoadFrom(assemblyName);
+            }
+            catch (Exception e)
+            {
+                throw new WixException(WixErrors.InvalidExtension(assemblyName, e.Message));
+            }
+
+            return extensionAssembly;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Extensibility/IHarvesterCore.cs b/src/WixToolset.Core/Extensibility/IHarvesterCore.cs
new file mode 100644
index 00000000..9a6fd10c
--- /dev/null
+++ b/src/WixToolset.Core/Extensibility/IHarvesterCore.cs
@@ -0,0 +1,62 @@
+// 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
+{
+    using System;
+    using System.Diagnostics.CodeAnalysis;
+    using System.IO;
+    using WixToolset.Data;
+    using Wix = WixToolset.Data.Serialize;
+
+    /// <summary>
+    /// The WiX Toolset harvester core.
+    /// </summary>
+    public interface IHarvesterCore
+    {
+        /// <summary>
+        /// Gets whether the harvester core encountered an error while processing.
+        /// </summary>
+        /// <value>Flag if core encountered an error during processing.</value>
+        bool EncounteredError { get; }
+
+        /// <summary>
+        /// Gets or sets the value of the extension argument passed to heat.
+        /// </summary>
+        /// <value>The extension argument.</value>
+        string ExtensionArgument { get; set; }
+
+        /// <summary>
+        /// Gets or sets the value of the root directory that is being harvested.
+        /// </summary>
+        /// <value>The root directory being harvested.</value>
+        string RootDirectory { get; set; }
+
+        /// <summary>
+        /// Create an identifier based on passed file name
+        /// </summary>
+        /// <param name="name">File name to generate identifer from</param>
+        /// <returns></returns>
+        string CreateIdentifierFromFilename(string filename);
+
+        /// <summary>
+        /// Generate an identifier by hashing data from the row.
+        /// </summary>
+        /// <param name="prefix">Three letter or less prefix for generated row identifier.</param>
+        /// <param name="args">Information to hash.</param>
+        /// <returns>The generated identifier.</returns>
+        string GenerateIdentifier(string prefix, params string[] args);
+
+        /// <summary>
+        /// Sends a message to the message delegate if there is one.
+        /// </summary>
+        /// <param name="mea">Message event arguments.</param>
+        void OnMessage(MessageEventArgs mea);
+
+        /// <summary>
+        /// Resolves a file's path if the Wix.File.Source value starts with "SourceDir\".
+        /// </summary>
+        /// <param name="fileSource">The Wix.File.Source value with "SourceDir\".</param>
+        /// <returns>The full path of the file.</returns>
+        string ResolveFilePath(string fileSource);
+    }
+}
diff --git a/src/WixToolset.Core/Extensibility/IHeatCore.cs b/src/WixToolset.Core/Extensibility/IHeatCore.cs
new file mode 100644
index 00000000..bc853b24
--- /dev/null
+++ b/src/WixToolset.Core/Extensibility/IHeatCore.cs
@@ -0,0 +1,36 @@
+// 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.Extensibilty
+{
+    using WixToolset.Data;
+
+    /// <summary>
+    /// The WiX Toolset Harvester application core.
+    /// </summary>
+    public interface IHeatCore
+    {
+        /// <summary>
+        /// Gets whether the mutator core encountered an error while processing.
+        /// </summary>
+        /// <value>Flag if core encountered an error during processing.</value>
+        bool EncounteredError { get; }
+
+        /// <summary>
+        /// Gets the harvester.
+        /// </summary>
+        /// <value>The harvester.</value>
+        Harvester Harvester { get; }
+
+        /// <summary>
+        /// Gets the mutator.
+        /// </summary>
+        /// <value>The mutator.</value>
+        Mutator Mutator { get; }
+
+        /// <summary>
+        /// Sends a message to the message delegate if there is one.
+        /// </summary>
+        /// <param name="mea">Message event arguments.</param>
+        void OnMessage(MessageEventArgs mea);
+    }
+}
diff --git a/src/WixToolset.Core/Extensibility/MutatorExtension.cs b/src/WixToolset.Core/Extensibility/MutatorExtension.cs
new file mode 100644
index 00000000..9de64180
--- /dev/null
+++ b/src/WixToolset.Core/Extensibility/MutatorExtension.cs
@@ -0,0 +1,198 @@
+// 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.Extensibility
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Text;
+
+    using Wix = WixToolset.Data.Serialize;
+
+    /// <summary>
+    /// The base mutator extension.  Any of these methods can be overridden to change
+    /// the behavior of the mutator.
+    /// </summary>
+    public abstract class MutatorExtension
+    {
+        /// <summary>
+        /// Gets or sets the mutator core for the extension.
+        /// </summary>
+        /// <value>The mutator core for the extension.</value>
+        public IHarvesterCore Core { get; set; }
+
+        /// <summary>
+        /// Gets the sequence of the extension.
+        /// </summary>
+        /// <value>The sequence of the extension.</value>
+        public abstract int Sequence
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Mutate a WiX document.
+        /// </summary>
+        /// <param name="wix">The Wix document element.</param>
+        public virtual void Mutate(Wix.Wix wix)
+        {
+        }
+
+        /// <summary>
+        /// Mutate a WiX document as a string.
+        /// </summary>
+        /// <param name="wix">The Wix document element as a string.</param>
+        /// <returns>The mutated Wix document as a string.</returns>
+        public virtual string Mutate(string wixString)
+        {
+            return wixString;
+        }
+
+        /// <summary>
+        /// Generate unique MSI identifiers.
+        /// </summary>
+        protected class IdentifierGenerator
+        {
+            public const int MaxProductIdentifierLength = 72;
+            public const int MaxModuleIdentifierLength = 35;
+
+            private string baseName;
+            private int maxLength;
+            private Dictionary<string, object> existingIdentifiers;
+            private Dictionary<string, object> possibleIdentifiers;
+
+            /// <summary>
+            /// Instantiate a new IdentifierGenerator.
+            /// </summary>
+            /// <param name="baseName">The base resource name to use if a resource name contains no usable characters.</param>
+            public IdentifierGenerator(string baseName)
+            {
+                this.baseName = baseName;
+                this.maxLength = IdentifierGenerator.MaxProductIdentifierLength;
+                this.existingIdentifiers = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
+                this.possibleIdentifiers = new Dictionary<string, object>(StringComparer.OrdinalIgnoreCase);
+            }
+
+            /// <summary>
+            /// Gets or sets the maximum length for generated identifiers.
+            /// </summary>
+            /// <value>Maximum length for generated identifiers. (Default is 72.)</value>
+            public int MaxIdentifierLength
+            {
+                get { return this.maxLength; }
+                set { this.maxLength = value; }
+            }
+
+            /// <summary>
+            /// Index an existing identifier for collision detection.
+            /// </summary>
+            /// <param name="identifier">The identifier.</param>
+            public void IndexExistingIdentifier(string identifier)
+            {
+                if (null == identifier)
+                {
+                    throw new ArgumentNullException("identifier");
+                }
+
+                this.existingIdentifiers[identifier] = null;
+            }
+
+            /// <summary>
+            /// Index a resource name for collision detection.
+            /// </summary>
+            /// <param name="name">The resource name.</param>
+            public void IndexName(string name)
+            {
+                if (null == name)
+                {
+                    throw new ArgumentNullException("name");
+                }
+
+                string identifier = this.CreateIdentifier(name, 0);
+
+                if (this.possibleIdentifiers.ContainsKey(identifier))
+                {
+                    this.possibleIdentifiers[identifier] = String.Empty;
+                }
+                else
+                {
+                    this.possibleIdentifiers.Add(identifier, null);
+                }
+            }
+
+            /// <summary>
+            /// Get the identifier for the given resource name.
+            /// </summary>
+            /// <param name="name">The resource name.</param>
+            /// <returns>A legal MSI identifier.</returns>
+            [SuppressMessage("Microsoft.Globalization", "CA1303:DoNotPassLiteralsAsLocalizedParameters", MessageId = "System.InvalidOperationException.#ctor(System.String)")]
+            public string GetIdentifier(string name)
+            {
+                if (null == name)
+                {
+                    throw new ArgumentNullException("name");
+                }
+
+                for (int i = 0; i <= Int32.MaxValue; i++)
+                {
+                    string identifier = this.CreateIdentifier(name, i);
+
+                    if (this.existingIdentifiers.ContainsKey(identifier) || // already used
+                        (0 == i && 0 != this.possibleIdentifiers.Count && null != this.possibleIdentifiers[identifier]) || // needs an index because its duplicated
+                        (0 != i && this.possibleIdentifiers.ContainsKey(identifier))) // collides with another possible identifier
+                    {
+                        continue;
+                    }
+                    else // use this identifier
+                    {
+                        this.existingIdentifiers.Add(identifier, null);
+
+                        return identifier;
+                    }
+                }
+
+                throw new InvalidOperationException(WixStrings.EXP_CouldnotFileUniqueIDForResourceName);
+            }
+
+            /// <summary>
+            /// Create a legal MSI identifier from a resource name and an index.
+            /// </summary>
+            /// <param name="name">The name of the resource for which an identifier should be created.</param>
+            /// <param name="index">An index to append to the end of the identifier to make it unique.</param>
+            /// <returns>A legal MSI identifier.</returns>
+            public string CreateIdentifier(string name, int index)
+            {
+                if (null == name)
+                {
+                    throw new ArgumentNullException("name");
+                }
+
+                StringBuilder identifier = new StringBuilder();
+
+                // Convert the name to a standard MSI identifier
+                identifier.Append(Common.GetIdentifierFromName(name));
+
+                // no legal identifier characters were found, use the base id instead
+                if (0 == identifier.Length)
+                {
+                    identifier.Append(this.baseName);
+                }
+
+                // truncate the identifier if it's too long (reserve 3 characters for up to 99 collisions)
+                int adjustedMaxLength = this.MaxIdentifierLength - (index != 0 ? 3 : 0);
+                if (adjustedMaxLength < identifier.Length)
+                {
+                    identifier.Length = adjustedMaxLength;
+                }
+
+                // if the index is not zero, then append it to the identifier name
+                if (0 != index)
+                {
+                    identifier.AppendFormat("_{0}", index);
+                }
+
+                return identifier.ToString();
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Extensibility/ValidatorExtension.cs b/src/WixToolset.Core/Extensibility/ValidatorExtension.cs
new file mode 100644
index 00000000..44ec3106
--- /dev/null
+++ b/src/WixToolset.Core/Extensibility/ValidatorExtension.cs
@@ -0,0 +1,299 @@
+// 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.Extensibility
+{
+    using System;
+    using System.Collections;
+    using WixToolset.Data;
+
+    /// <summary>
+    /// Base class for creating a validator extension. This default implementation
+    /// will fire and event with the ICE name and description.
+    /// </summary>
+    public class ValidatorExtension : IMessageHandler
+    {
+        private string databaseFile;
+        private Hashtable indexedSourceLineNumbers;
+        private Output output;
+        private SourceLineNumber sourceLineNumbers;
+
+        /// <summary>
+        /// Instantiate a new <see cref="ValidatorExtension"/>.
+        /// </summary>
+        public ValidatorExtension()
+        {
+        }
+
+        /// <summary>
+        /// Gets or sets the path to the database to validate.
+        /// </summary>
+        /// <value>The path to the database to validate.</value>
+        public string DatabaseFile
+        {
+            get { return this.databaseFile; }
+            set { this.databaseFile = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the <see cref="Output"/> for finding source line information.
+        /// </summary>
+        /// <value>The <see cref="Output"/> for finding source line information.</value>
+        public Output Output
+        {
+            get { return this.output; }
+            set { this.output = value; }
+        }
+
+        /// <summary>
+        /// Called at the beginning of the validation of a database file.
+        /// </summary>
+        /// <remarks>
+        /// <para>The <see cref="Validator"/> will set
+        /// <see cref="DatabaseFile"/> before calling InitializeValidator.</para>
+        /// <para><b>Notes to Inheritors:</b> When overriding
+        /// <b>InitializeValidator</b> in a derived class, be sure to call
+        /// the base class's <b>InitializeValidator</b> to thoroughly
+        /// initialize the extension.</para>
+        /// </remarks>
+        public virtual void InitializeValidator()
+        {
+            if (this.databaseFile != null)
+            {
+                this.sourceLineNumbers = new SourceLineNumber(databaseFile);
+            }
+        }
+
+        /// <summary>
+        /// Called at the end of the validation of a database file.
+        /// </summary>
+        /// <remarks>
+        /// <para>The default implementation will nullify source lines.</para>
+        /// <para><b>Notes to Inheritors:</b> When overriding
+        /// <b>FinalizeValidator</b> in a derived class, be sure to call
+        /// the base class's <b>FinalizeValidator</b> to thoroughly
+        /// finalize the extension.</para>
+        /// </remarks>
+        public virtual void FinalizeValidator()
+        {
+            this.sourceLineNumbers = null;
+        }
+
+        /// <summary>
+        /// Logs a message from the <see cref="Validator"/>.
+        /// </summary>
+        /// <param name="message">A <see cref="String"/> of tab-delmited tokens
+        /// in the validation message.</param>
+        public virtual void Log(string message)
+        {
+            this.Log(message, null);
+        }
+
+        /// <summary>
+        /// Logs a message from the <see cref="Validator"/>.
+        /// </summary>
+        /// <param name="message">A <see cref="String"/> of tab-delmited tokens
+        /// in the validation message.</param>
+        /// <param name="action">The name of the action to which the message
+        /// belongs.</param>
+        /// <exception cref="ArgumentNullException">The message cannot be null.
+        /// </exception>
+        /// <exception cref="WixException">The message does not contain four (4)
+        /// or more tab-delimited tokens.</exception>
+        /// <remarks>
+        /// <para><paramref name="message"/> a tab-delimited set of tokens,
+        /// formatted according to Windows Installer guidelines for ICE
+        /// message. The following table lists what each token by index
+        /// should mean.</para>
+        /// <para><paramref name="action"/> a name that represents the ICE
+        /// action that was executed (e.g. 'ICE08').</para>
+        /// <list type="table">
+        /// <listheader>
+        ///     <term>Index</term>
+        ///     <description>Description</description>
+        /// </listheader>
+        /// <item>
+        ///     <term>0</term>
+        ///     <description>Name of the ICE.</description>
+        /// </item>
+        /// <item>
+        ///     <term>1</term>
+        ///     <description>Message type. See the following list.</description>
+        /// </item>
+        /// <item>
+        ///     <term>2</term>
+        ///     <description>Detailed description.</description>
+        /// </item>
+        /// <item>
+        ///     <term>3</term>
+        ///     <description>Help URL or location.</description>
+        /// </item>
+        /// <item>
+        ///     <term>4</term>
+        ///     <description>Table name.</description>
+        /// </item>
+        /// <item>
+        ///     <term>5</term>
+        ///     <description>Column name.</description>
+        /// </item>
+        /// <item>
+        ///     <term>6</term>
+        ///     <description>This and remaining fields are primary keys
+        ///     to identify a row.</description>
+        /// </item>
+        /// </list>
+        /// <para>The message types are one of the following value.</para>
+        /// <list type="table">
+        /// <listheader>
+        ///     <term>Value</term>
+        ///     <description>Message Type</description>
+        /// </listheader>
+        /// <item>
+        ///     <term>0</term>
+        ///     <description>Failure message reporting the failure of the
+        ///     ICE custom action.</description>
+        /// </item>
+        /// <item>
+        ///     <term>1</term>
+        ///     <description>Error message reporting database authoring that
+        ///     case incorrect behavior.</description>
+        /// </item>
+        /// <item>
+        ///     <term>2</term>
+        ///     <description>Warning message reporting database authoring that
+        ///     causes incorrect behavior in certain cases. Warnings can also
+        ///     report unexpected side-effects of database authoring.
+        ///     </description>
+        /// </item>
+        /// <item>
+        ///     <term>3</term>
+        ///     <description>Informational message.</description>
+        /// </item>
+        /// </list>
+        /// </remarks>
+        public virtual void Log(string message, string action)
+        {
+            if (message == null)
+            {
+                throw new ArgumentNullException("message");
+            }
+
+            string[] messageParts = message.Split('\t');
+            if (3 > messageParts.Length)
+            {
+                if (null == action)
+                {
+                    throw new WixException(WixErrors.UnexpectedExternalUIMessage(message));
+                }
+                else
+                {
+                    throw new WixException(WixErrors.UnexpectedExternalUIMessage(message, action));
+                }
+            }
+
+            SourceLineNumber messageSourceLineNumbers = null;
+            if (6 < messageParts.Length)
+            {
+                string[] primaryKeys = new string[messageParts.Length - 6];
+
+                Array.Copy(messageParts, 6, primaryKeys, 0, primaryKeys.Length);
+
+                messageSourceLineNumbers = this.GetSourceLineNumbers(messageParts[4], primaryKeys);
+            }
+            else // use the file name as the source line information
+            {
+                messageSourceLineNumbers = this.sourceLineNumbers;
+            }
+
+            switch (messageParts[1])
+            {
+                case "0":
+                case "1":
+                    this.OnMessage(WixErrors.ValidationError(messageSourceLineNumbers, messageParts[0], messageParts[2]));
+                    break;
+                case "2":
+                    this.OnMessage(WixWarnings.ValidationWarning(messageSourceLineNumbers, messageParts[0], messageParts[2]));
+                    break;
+                case "3":
+                    this.OnMessage(WixVerboses.ValidationInfo(messageParts[0], messageParts[2]));
+                    break;
+                default:
+                    throw new WixException(WixErrors.InvalidValidatorMessageType(messageParts[1]));
+            }
+        }
+ 
+        /// <summary>
+        /// Gets the source line information (if available) for a row by its table name and primary key.
+        /// </summary>
+        /// <param name="tableName">The table name of the row.</param>
+        /// <param name="primaryKeys">The primary keys of the row.</param>
+        /// <returns>The source line number information if found; null otherwise.</returns>
+        protected SourceLineNumber GetSourceLineNumbers(string tableName, string[] primaryKeys)
+        {
+            // source line information only exists if an output file was supplied
+            if (null != this.output)
+            {
+                // index the source line information if it hasn't been indexed already
+                if (null == this.indexedSourceLineNumbers)
+                {
+                    this.indexedSourceLineNumbers = new Hashtable();
+
+                    // index each real table
+                    foreach (Table table in this.output.Tables)
+                    {
+                        // skip unreal tables
+                        if (table.Definition.Unreal)
+                        {
+                            continue;
+                        }
+
+                        // index each row
+                        foreach (Row row in table.Rows)
+                        {
+                            // skip rows that don't contain source line information
+                            if (null == row.SourceLineNumbers)
+                            {
+                                continue;
+                            }
+
+                            // index the row using its table name and primary key
+                            string primaryKey = row.GetPrimaryKey(';');
+                            if (null != primaryKey)
+                            {
+                                string key = String.Concat(table.Name, ":", primaryKey);
+
+                                if (this.indexedSourceLineNumbers.ContainsKey(key))
+                                {
+                                    this.OnMessage(WixWarnings.DuplicatePrimaryKey(row.SourceLineNumbers, primaryKey, table.Name));
+                                }
+                                else
+                                {
+                                    this.indexedSourceLineNumbers.Add(key, row.SourceLineNumbers);
+                                }
+                            }
+                        }
+                    }
+                }
+
+                return (SourceLineNumber)this.indexedSourceLineNumbers[String.Concat(tableName, ":", String.Join(";", primaryKeys))];
+            }
+
+            // use the file name as the source line information
+            return this.sourceLineNumbers;
+        }
+
+        /// <summary>
+        /// Sends a message to the <see cref="Message"/> delegate if there is one.
+        /// </summary>
+        /// <param name="e">Message event arguments.</param>
+        /// <remarks>
+        /// <para><b>Notes to Inheritors:</b> When overriding <b>OnMessage</b>
+        /// in a derived class, be sure to call the base class's
+        /// <b>OnMessage</b> method so that registered delegates recieve
+        /// the event.</para>
+        /// </remarks>
+        public virtual void OnMessage(MessageEventArgs e)
+        {
+            Messaging.Instance.OnMessage(e);
+        }
+   }
+}
diff --git a/src/WixToolset.Core/ExtensionManager.cs b/src/WixToolset.Core/ExtensionManager.cs
new file mode 100644
index 00000000..45cb65ec
--- /dev/null
+++ b/src/WixToolset.Core/ExtensionManager.cs
@@ -0,0 +1,110 @@
+// 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
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Linq;
+    using System.Reflection;
+    using WixToolset.Data;
+
+    public class ExtensionManager
+    {
+        private List<Assembly> extensionAssemblies = new List<Assembly>();
+
+        /// <summary>
+        /// Loads an assembly from a type description string.
+        /// </summary>
+        /// <param name="extension">The assembly type description string.</param>
+        /// <returns>The loaded assembly. This assembly can be ignored since the extension manager maintains the list of loaded assemblies internally.</returns>
+        /// <remarks>
+        /// <paramref name="extension"/> can be in several different forms:
+        /// <list type="number">
+        /// <item><term>AssemblyName (MyAssembly, Version=1.3.0.0, Culture=neutral, PublicKeyToken=b17a5c561934e089)</term></item>
+        /// <item><term>Absolute path to an assembly (C:\MyExtensions\ExtensionAssembly.dll)</term></item>
+        /// <item><term>Filename of an assembly in the application directory (ExtensionAssembly.dll)</term></item>
+        /// <item><term>Relative path to an assembly (..\..\MyExtensions\ExtensionAssembly.dll)</term></item>
+        /// </list>
+        /// </remarks>
+        public Assembly Load(string extension)
+        {
+            string assemblyName = extension;
+            Assembly assembly;
+
+            // Absolute path to an assembly which means only "load from" will work even though we'd prefer to
+            // use Assembly.Load (see the documentation for Assembly.LoadFrom why).
+            if (Path.IsPathRooted(assemblyName))
+            {
+                assembly = ExtensionManager.ExtensionLoadFrom(assemblyName);
+            }
+            else if (ExtensionManager.TryExtensionLoad(assemblyName, out assembly))
+            {
+                // Loaded the assembly by name from the probing path.
+            }
+            else if (ExtensionManager.TryExtensionLoad(Path.GetFileNameWithoutExtension(assemblyName), out assembly))
+            {
+                // Loaded the assembly by filename alone along the probing path.
+            }
+            else // relative path to an assembly
+            {
+                // We want to use Assembly.Load when we can because it has some benefits over Assembly.LoadFrom
+                // (see the documentation for Assembly.LoadFrom). However, it may fail when the path is a relative
+                // path, so we should try Assembly.LoadFrom one last time. We could have detected a directory
+                // separator character and used Assembly.LoadFrom directly, but dealing with path canonicalization
+                // issues is something we don't want to deal with if we don't have to.
+                assembly = ExtensionManager.ExtensionLoadFrom(assemblyName);
+            }
+
+            this.extensionAssemblies.Add(assembly);
+            return assembly;
+        }
+
+        /// <summary>
+        /// Creates extension of specified type from assemblies loaded into the extension manager.
+        /// </summary>
+        /// <typeparam name="T">Type of extension to create.</typeparam>
+        /// <returns>Extensions created of the specified type.</returns>
+        public IEnumerable<T> Create<T>() where T : class
+        {
+            var extensionType = typeof(T);
+            var types = this.extensionAssemblies.SelectMany(a => a.GetTypes().Where(t => !t.IsAbstract && !t.IsInterface && extensionType.IsAssignableFrom(t)));
+            return types.Select(t => (T)Activator.CreateInstance(t)).ToList();
+        }
+
+        private static Assembly ExtensionLoadFrom(string assemblyName)
+        {
+            try
+            {
+                return Assembly.LoadFrom(assemblyName);
+            }
+            catch (Exception e)
+            {
+                throw new WixException(WixErrors.InvalidExtension(assemblyName, e.Message), e);
+            }
+        }
+
+        private static bool TryExtensionLoad(string assemblyName, out Assembly assembly)
+        {
+            try
+            {
+                assembly = Assembly.Load(assemblyName);
+                return true;
+            }
+            catch (IOException innerE)
+            {
+                if (innerE is FileLoadException || innerE is FileNotFoundException)
+                {
+                    assembly = null;
+                    return false;
+                }
+
+                throw new WixException(WixErrors.InvalidExtension(assemblyName, innerE.Message), innerE);
+            }
+            catch (Exception e)
+            {
+                throw new WixException(WixErrors.InvalidExtension(assemblyName, e.Message), e);
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/GlobalSuppressions.cs b/src/WixToolset.Core/GlobalSuppressions.cs
new file mode 100644
index 00000000..4b283c52
--- /dev/null
+++ b/src/WixToolset.Core/GlobalSuppressions.cs
@@ -0,0 +1,24 @@
+// 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.
+
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1020:AvoidNamespacesWithFewTypes", Scope = "namespace", Target = "WixToolset.Cab")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1008:EnumsShouldHaveZeroValue", Scope = "type", Target = "WixToolset.Msi.InstallMessage")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1008:EnumsShouldHaveZeroValue", Scope = "type", Target = "WixToolset.Msi.InstallUILevels")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1027:MarkEnumsWithFlags", Scope = "type", Target = "WixToolset.Msi.OpenDatabase")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1032:ImplementStandardExceptionConstructors")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1036:OverrideMethodsOnComparableTypes")]
+
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Maintainability", "CA1502:AvoidExcessiveComplexity")]
+
+// .NET 2.0 requirement
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2000:DisposeObjectsBeforeLosingScope", Scope = "member", Target = "WixToolset.Intermediate.Load(System.String,WixToolset.TableDefinitionCollection,System.Boolean,System.Boolean):WixToolset.Intermediate")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2000:DisposeObjectsBeforeLosingScope", Scope = "member", Target = "WixToolset.Library.Load(System.IO.Stream,System.Uri,WixToolset.TableDefinitionCollection,System.Boolean,System.Boolean):WixToolset.Library")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2000:DisposeObjectsBeforeLosingScope", Scope = "member", Target = "WixToolset.Localization.Load(System.IO.Stream,System.Uri,WixToolset.TableDefinitionCollection,System.Boolean):WixToolset.Localization")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2000:DisposeObjectsBeforeLosingScope", Scope = "member", Target = "WixToolset.Output.Load(System.IO.Stream,System.Uri,System.Boolean,System.Boolean):WixToolset.Output")]
+
+// .NET 2.0 requirement
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Reliability", "CA2006:UseSafeHandleToEncapsulateNativeResources", Scope = "member", Target = "WixToolset.Cab.WixCreateCab.handle")]
+
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "Msi", Scope = "namespace", Target = "WixToolset.Msi")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "wix")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1709:IdentifiersShouldBeCasedCorrectly", MessageId = "wix")]
+[assembly: System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA1704:IdentifiersShouldBeSpelledCorrectly", MessageId = "wx")]
diff --git a/src/WixToolset.Core/Harvester.cs b/src/WixToolset.Core/Harvester.cs
new file mode 100644
index 00000000..0f79a2d6
--- /dev/null
+++ b/src/WixToolset.Core/Harvester.cs
@@ -0,0 +1,80 @@
+// 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
+{
+    using System;
+    using System.Collections;
+    using System.Diagnostics.CodeAnalysis;
+    using WixToolset.Data;
+    using Wix = WixToolset.Data.Serialize;
+
+    /// <summary>
+    /// The WiX Toolset harvester.
+    /// </summary>
+    public sealed class Harvester
+    {
+        private HarvesterExtension harvesterExtension;
+
+        /// <summary>
+        /// Gets or sets the harvester core for the extension.
+        /// </summary>
+        /// <value>The harvester core for the extension.</value>
+        public IHarvesterCore Core { get; set; }
+
+        /// <summary>
+        /// Gets or sets the extension.
+        /// </summary>
+        /// <value>The extension.</value>
+        [SuppressMessage("Microsoft.Globalization", "CA1303:DoNotPassLiteralsAsLocalizedParameters", MessageId = "System.InvalidOperationException.#ctor(System.String)")]
+        public HarvesterExtension Extension
+        {
+            get
+            {
+                return this.harvesterExtension;
+            }
+            set
+            {
+                if (null != this.harvesterExtension)
+                {
+                    throw new InvalidOperationException(WixStrings.EXP_MultipleHarvesterExtensionsSpecified);
+                }
+
+                this.harvesterExtension = value;
+            }
+        }
+
+        /// <summary>
+        /// Harvest wix authoring.
+        /// </summary>
+        /// <param name="argument">The argument for harvesting.</param>
+        /// <returns>The harvested wix authoring.</returns>
+        public Wix.Wix Harvest(string argument)
+        {
+            if (null == argument)
+            {
+                throw new ArgumentNullException("argument");
+            }
+
+            if (null == this.harvesterExtension)
+            {
+                throw new WixException(WixErrors.HarvestTypeNotFound());
+            }
+
+            this.harvesterExtension.Core = this.Core;
+
+            Wix.Fragment[] fragments = this.harvesterExtension.Harvest(argument);
+            if (null == fragments || 0 == fragments.Length)
+            {
+                return null;
+            }
+
+            Wix.Wix wix = new Wix.Wix();
+            foreach (Wix.Fragment fragment in fragments)
+            {
+                wix.AddChild(fragment);
+            }
+
+            return wix;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/HarvesterCore.cs b/src/WixToolset.Core/HarvesterCore.cs
new file mode 100644
index 00000000..66a693f2
--- /dev/null
+++ b/src/WixToolset.Core/HarvesterCore.cs
@@ -0,0 +1,103 @@
+// 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
+{
+    using System;
+    using System.Diagnostics.CodeAnalysis;
+    using System.IO;
+    using WixToolset.Data;
+    using Wix = WixToolset.Data.Serialize;
+
+    /// <summary>
+    /// The WiX Toolset harvester core.
+    /// </summary>
+    public sealed class HarvesterCore : IHarvesterCore
+    {
+        private string extensionArgument;
+        private string rootDirectory;
+
+        /// <summary>
+        /// Gets whether the harvester core encountered an error while processing.
+        /// </summary>
+        /// <value>Flag if core encountered an error during processing.</value>
+        public bool EncounteredError
+        {
+            get { return Messaging.Instance.EncounteredError; }
+        }
+
+        /// <summary>
+        /// Gets or sets the value of the extension argument passed to heat.
+        /// </summary>
+        /// <value>The extension argument.</value>
+        public string ExtensionArgument
+        {
+            get { return this.extensionArgument; }
+            set { this.extensionArgument = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the value of the root directory that is being harvested.
+        /// </summary>
+        /// <value>The root directory being harvested.</value>
+        public string RootDirectory
+        {
+            get { return this.rootDirectory; }
+            set { this.rootDirectory = value; }
+        }
+
+        /// <summary>
+        /// Create an identifier based on passed file name
+        /// </summary>
+        /// <param name="name">File name to generate identifer from</param>
+        /// <returns></returns>
+        public string CreateIdentifierFromFilename(string filename)
+        {
+            return Common.GetIdentifierFromName(filename);
+        }
+
+        /// <summary>
+        /// Generate an identifier by hashing data from the row.
+        /// </summary>
+        /// <param name="prefix">Three letter or less prefix for generated row identifier.</param>
+        /// <param name="args">Information to hash.</param>
+        /// <returns>The generated identifier.</returns>
+        [SuppressMessage("Microsoft.Globalization", "CA1303:DoNotPassLiteralsAsLocalizedParameters", MessageId = "System.InvalidOperationException.#ctor(System.String)")]
+        public string GenerateIdentifier(string prefix, params string[] args)
+        {
+            return Common.GenerateIdentifier(prefix, args);
+        }
+
+        /// <summary>
+        /// Sends a message to the message delegate if there is one.
+        /// </summary>
+        /// <param name="mea">Message event arguments.</param>
+        public void OnMessage(MessageEventArgs mea)
+        {
+            Messaging.Instance.OnMessage(mea);
+        }
+
+        /// <summary>
+        /// Resolves a file's path if the Wix.File.Source value starts with "SourceDir\".
+        /// </summary>
+        /// <param name="fileSource">The Wix.File.Source value with "SourceDir\".</param>
+        /// <returns>The full path of the file.</returns>
+        public string ResolveFilePath(string fileSource)
+        {
+            if (fileSource.StartsWith("SourceDir\\", StringComparison.Ordinal))
+            {
+                string file = Path.GetFullPath(this.rootDirectory);
+                if (File.Exists(file))
+                {
+                    return file;
+                }
+                else
+                {
+                    fileSource = fileSource.Substring(10);
+                    fileSource = Path.Combine(Path.GetFullPath(this.rootDirectory), fileSource);
+                }
+            }
+
+            return fileSource;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/HeatCore.cs b/src/WixToolset.Core/HeatCore.cs
new file mode 100644
index 00000000..5c5defe8
--- /dev/null
+++ b/src/WixToolset.Core/HeatCore.cs
@@ -0,0 +1,65 @@
+// 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.Tools
+{
+    using System;
+    using System.Reflection;
+    using WixToolset.Data;
+    using WixToolset.Extensibilty;
+    using Wix = WixToolset.Data.Serialize;
+
+    /// <summary>
+    /// The WiX Toolset Harvester application core.
+    /// </summary>
+    public sealed class HeatCore : IHeatCore, IMessageHandler
+    {
+        private Harvester harvester;
+        private Mutator mutator;
+
+        /// <summary>
+        /// Instantiates a new HeatCore.
+        /// </summary>
+        /// <param name="messageHandler">The message handler for the core.</param>
+        public HeatCore()
+        {
+            this.harvester = new Harvester();
+            this.mutator = new Mutator();
+        }
+
+        /// <summary>
+        /// Gets whether the mutator core encountered an error while processing.
+        /// </summary>
+        /// <value>Flag if core encountered an error during processing.</value>
+        public bool EncounteredError
+        {
+            get { return Messaging.Instance.EncounteredError; }
+        }
+
+        /// <summary>
+        /// Gets the harvester.
+        /// </summary>
+        /// <value>The harvester.</value>
+        public Harvester Harvester
+        {
+            get { return this.harvester; }
+        }
+
+        /// <summary>
+        /// Gets the mutator.
+        /// </summary>
+        /// <value>The mutator.</value>
+        public Mutator Mutator
+        {
+            get { return this.mutator; }
+        }
+
+        /// <summary>
+        /// Sends a message to the message delegate if there is one.
+        /// </summary>
+        /// <param name="mea">Message event arguments.</param>
+        public void OnMessage(MessageEventArgs mea)
+        {
+            Messaging.Instance.OnMessage(mea);
+        }
+    }
+}
diff --git a/src/WixToolset.Core/ICommand.cs b/src/WixToolset.Core/ICommand.cs
new file mode 100644
index 00000000..957f735b
--- /dev/null
+++ b/src/WixToolset.Core/ICommand.cs
@@ -0,0 +1,9 @@
+// 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
+{
+    internal interface ICommand
+    {
+        void Execute();
+    }
+}
diff --git a/src/WixToolset.Core/IfDefEventHandler.cs b/src/WixToolset.Core/IfDefEventHandler.cs
new file mode 100644
index 00000000..37a7206e
--- /dev/null
+++ b/src/WixToolset.Core/IfDefEventHandler.cs
@@ -0,0 +1,46 @@
+// 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
+{
+    using System;
+    using System.Text;
+    using WixToolset.Data;
+
+    public delegate void IfDefEventHandler(object sender, IfDefEventArgs e);
+
+    public class IfDefEventArgs : EventArgs
+    {
+        private SourceLineNumber sourceLineNumbers;
+        private bool isIfDef;
+        private bool isDefined;
+        private string variableName;
+
+        public IfDefEventArgs(SourceLineNumber sourceLineNumbers, bool isIfDef, bool isDefined, string variableName)
+        {
+            this.sourceLineNumbers = sourceLineNumbers;
+            this.isIfDef = isIfDef;
+            this.isDefined = isDefined;
+            this.variableName = variableName;
+        }
+
+        public SourceLineNumber SourceLineNumbers
+        {
+            get { return this.sourceLineNumbers; }
+        }
+
+        public bool IsDefined
+        {
+            get { return this.isDefined; }
+        }
+
+        public bool IsIfDef
+        {
+            get { return this.isIfDef; }
+        }
+
+        public string VariableName
+        {
+            get { return this.variableName; }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/IncludedFileEventHandler.cs b/src/WixToolset.Core/IncludedFileEventHandler.cs
new file mode 100644
index 00000000..57527e5c
--- /dev/null
+++ b/src/WixToolset.Core/IncludedFileEventHandler.cs
@@ -0,0 +1,52 @@
+// 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
+{
+    using System;
+    using WixToolset.Data;
+
+    /// <summary>
+    /// Included file event handler delegate.
+    /// </summary>
+    /// <param name="sender">Sender of the message.</param>
+    /// <param name="ea">Arguments for the included file event.</param>
+    public delegate void IncludedFileEventHandler(object sender, IncludedFileEventArgs e);
+
+    /// <summary>
+    /// Event args for included file event.
+    /// </summary>
+    public class IncludedFileEventArgs : EventArgs
+    {
+        private SourceLineNumber sourceLineNumbers;
+        private string fullName;
+
+        /// <summary>
+        /// Creates a new IncludedFileEventArgs.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line numbers for the included file.</param>
+        /// <param name="fullName">The full path of the included file.</param>
+        public IncludedFileEventArgs(SourceLineNumber sourceLineNumbers, string fullName)
+        {
+            this.sourceLineNumbers = sourceLineNumbers;
+            this.fullName = fullName;
+        }
+
+        /// <summary>
+        /// Gets the full path of the included file.
+        /// </summary>
+        /// <value>The full path of the included file.</value>
+        public string FullName
+        {
+            get { return this.fullName; }
+        }
+
+        /// <summary>
+        /// Gets the source line numbers.
+        /// </summary>
+        /// <value>The source line numbers.</value>
+        public SourceLineNumber SourceLineNumbers
+        {
+            get { return this.sourceLineNumbers; }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Inscriber.cs b/src/WixToolset.Core/Inscriber.cs
new file mode 100644
index 00000000..5b467ec1
--- /dev/null
+++ b/src/WixToolset.Core/Inscriber.cs
@@ -0,0 +1,457 @@
+// 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
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.IO;
+    using System.Runtime.InteropServices;
+    using System.Security.Cryptography.X509Certificates;
+    using WixToolset.Bind.Bundles;
+    using WixToolset.Data;
+    using WixToolset.Msi;
+    using WixToolset.Core.Native;
+
+    /// <summary>
+    /// Converts a wixout representation of an MSM database into a ComponentGroup the form of WiX source.
+    /// </summary>
+    public sealed class Inscriber : IMessageHandler
+    {
+        // private TempFileCollection tempFiles;
+        private TableDefinitionCollection tableDefinitions;
+
+        public Inscriber()
+        {
+            this.tableDefinitions = new TableDefinitionCollection(WindowsInstallerStandard.GetTableDefinitions());
+        }
+
+        /// <summary>
+        /// Gets or sets the temp files collection.
+        /// </summary>
+        /// <value>The temp files collection.</value>
+        // public TempFileCollection TempFiles
+        // {
+        //     get { return this.tempFiles; }
+        //     set { this.tempFiles = value; }
+        // }
+
+        /// <summary>
+        /// Gets or sets the path to the temp files location.
+        /// </summary>
+        /// <value>The path to the temp files location.</value>
+        public string TempFilesLocation
+        {
+            get
+            {
+                // if (null == this.tempFiles)
+                // {
+                //     return null;
+                // }
+                // else
+                // {
+                //     return this.tempFiles.BasePath;
+                // }
+                return Path.GetTempPath();
+            }
+        //     set
+        //     {
+        //         this.DeleteTempFiles();
+
+        //         if (null == value)
+        //         {
+        //             this.tempFiles = new TempFileCollection();
+        //         }
+        //         else
+        //         {
+        //             this.tempFiles = new TempFileCollection(value);
+        //         }
+
+        //         // ensure the base path exists
+        //         Directory.CreateDirectory(this.tempFiles.BasePath);
+        //     }
+        }
+
+        /// <summary>
+        /// Extracts engine from attached container and updates engine with detached container signatures.
+        /// </summary>
+        /// <param name="bundleFile">Bundle with attached container.</param>
+        /// <param name="outputFile">Bundle engine only.</param>
+        /// <returns>True if bundle was updated.</returns>
+        public bool InscribeBundleEngine(string bundleFile, string outputFile)
+        {
+            string tempFile = Path.Combine(this.TempFilesLocation, "bundle_engine_unsigned.exe");
+
+            using (BurnReader reader = BurnReader.Open(bundleFile))
+            using (FileStream writer = File.Open(tempFile, FileMode.Create, FileAccess.Write, FileShare.Read | FileShare.Delete))
+            {
+                reader.Stream.Seek(0, SeekOrigin.Begin);
+
+                byte[] buffer = new byte[4 * 1024];
+                int total = 0;
+                int read = 0;
+                do
+                {
+                    read = Math.Min(buffer.Length, (int)reader.EngineSize - total);
+
+                    read = reader.Stream.Read(buffer, 0, read);
+                    writer.Write(buffer, 0, read);
+
+                    total += read;
+                } while (total < reader.EngineSize && 0 < read);
+
+                if (total != reader.EngineSize)
+                {
+                    throw new InvalidOperationException("Failed to copy engine out of bundle.");
+                }
+
+                // TODO: update writer with detached container signatures.
+            }
+
+            Directory.CreateDirectory(Path.GetDirectoryName(outputFile));
+            if (File.Exists(outputFile))
+            {
+                File.Delete(outputFile);
+            }
+            File.Move(tempFile, outputFile);
+            WixToolset.Core.Native.NativeMethods.ResetAcls(new string[] { outputFile }, 1);
+
+            return true;
+        }
+
+        /// <summary>
+        /// Updates engine with attached container information and adds attached container again.
+        /// </summary>
+        /// <param name="bundleFile">Bundle with attached container.</param>
+        /// <param name="signedEngineFile">Signed bundle engine.</param>
+        /// <param name="outputFile">Signed engine with attached container.</param>
+        /// <returns>True if bundle was updated.</returns>
+        public bool InscribeBundle(string bundleFile, string signedEngineFile, string outputFile)
+        {
+            bool inscribed = false;
+            string tempFile = Path.Combine(this.TempFilesLocation, "bundle_engine_signed.exe");
+
+            using (BurnReader reader = BurnReader.Open(bundleFile))
+            {
+                File.Copy(signedEngineFile, tempFile, true);
+
+                // If there was an attached container on the original (unsigned) bundle, put it back.
+                if (reader.AttachedContainerSize > 0)
+                {
+                    reader.Stream.Seek(reader.AttachedContainerAddress, SeekOrigin.Begin);
+
+                    using (BurnWriter writer = BurnWriter.Open(tempFile))
+                    {
+                        writer.RememberThenResetSignature();
+                        writer.AppendContainer(reader.Stream, reader.AttachedContainerSize, BurnCommon.Container.Attached);
+                        inscribed = true;
+                    }
+                }
+            }
+
+            Directory.CreateDirectory(Path.GetDirectoryName(outputFile));
+            if (File.Exists(outputFile))
+            {
+                File.Delete(outputFile);
+            }
+            File.Move(tempFile, outputFile);
+            WixToolset.Core.Native.NativeMethods.ResetAcls(new string[] { outputFile }, 1);
+
+            return inscribed;
+        }
+
+        /// <summary>
+        /// Updates database with signatures from external cabinets.
+        /// </summary>
+        /// <param name="databaseFile">Path to MSI database.</param>
+        /// <param name="outputFile">Ouput for updated MSI database.</param>
+        /// <param name="tidy">Clean up files.</param>
+        /// <returns>True if database is updated.</returns>
+        public bool InscribeDatabase(string databaseFile, string outputFile, bool tidy)
+        {
+            // Keeps track of whether we've encountered at least one signed cab or not - we'll throw a warning if no signed cabs were encountered
+            bool foundUnsignedExternals = false;
+            bool shouldCommit = false;
+
+            FileAttributes attributes = File.GetAttributes(databaseFile);
+            if (FileAttributes.ReadOnly == (attributes & FileAttributes.ReadOnly))
+            {
+                this.OnMessage(WixErrors.ReadOnlyOutputFile(databaseFile));
+                return shouldCommit;
+            }
+
+            using (Database database = new Database(databaseFile, OpenDatabase.Transact))
+            {
+                // Just use the English codepage, because the tables we're importing only have binary streams / MSI identifiers / other non-localizable content
+                int codepage = 1252;
+
+                // list of certificates for this database (hash/identifier)
+                Dictionary<string, string> certificates = new Dictionary<string, string>();
+
+                // Reset the in-memory tables for this new database
+                Table digitalSignatureTable = new Table(null, this.tableDefinitions["MsiDigitalSignature"]);
+                Table digitalCertificateTable = new Table(null, this.tableDefinitions["MsiDigitalCertificate"]);
+
+                // If any digital signature records exist that are not of the media type, preserve them
+                if (database.TableExists("MsiDigitalSignature"))
+                {
+                    using (View digitalSignatureView = database.OpenExecuteView("SELECT `Table`, `SignObject`, `DigitalCertificate_`, `Hash` FROM `MsiDigitalSignature` WHERE `Table` <> 'Media'"))
+                    {
+                        while (true)
+                        {
+                            using (Record digitalSignatureRecord = digitalSignatureView.Fetch())
+                            {
+                                if (null == digitalSignatureRecord)
+                                {
+                                    break;
+                                }
+
+                                Row digitalSignatureRow = null;
+                                digitalSignatureRow = digitalSignatureTable.CreateRow(null);
+
+                                string table = digitalSignatureRecord.GetString(0);
+                                string signObject = digitalSignatureRecord.GetString(1);
+
+                                digitalSignatureRow[0] = table;
+                                digitalSignatureRow[1] = signObject;
+                                digitalSignatureRow[2] = digitalSignatureRecord.GetString(2);
+
+                                if (false == digitalSignatureRecord.IsNull(3))
+                                {
+                                    // Export to a file, because the MSI API's require us to provide a file path on disk
+                                    string hashPath = Path.Combine(this.TempFilesLocation, "MsiDigitalSignature");
+                                    string hashFileName = string.Concat(table, ".", signObject, ".bin");
+
+                                    Directory.CreateDirectory(hashPath);
+                                    hashPath = Path.Combine(hashPath, hashFileName);
+
+                                    using (FileStream fs = File.Create(hashPath))
+                                    {
+                                        int bytesRead;
+                                        byte[] buffer = new byte[1024 * 4];
+
+                                        while (0 != (bytesRead = digitalSignatureRecord.GetStream(3, buffer, buffer.Length)))
+                                        {
+                                            fs.Write(buffer, 0, bytesRead);
+                                        }
+                                    }
+
+                                    digitalSignatureRow[3] = hashFileName;
+                                }
+                            }
+                        }
+                    }
+                }
+
+                // If any digital certificates exist, extract and preserve them
+                if (database.TableExists("MsiDigitalCertificate"))
+                {
+                    using (View digitalCertificateView = database.OpenExecuteView("SELECT * FROM `MsiDigitalCertificate`"))
+                    {
+                        while (true)
+                        {
+                            using (Record digitalCertificateRecord = digitalCertificateView.Fetch())
+                            {
+                                if (null == digitalCertificateRecord)
+                                {
+                                    break;
+                                }
+
+                                string certificateId = digitalCertificateRecord.GetString(1); // get the identifier of the certificate
+
+                                // Export to a file, because the MSI API's require us to provide a file path on disk
+                                string certPath = Path.Combine(this.TempFilesLocation, "MsiDigitalCertificate");
+                                Directory.CreateDirectory(certPath);
+                                certPath = Path.Combine(certPath, string.Concat(certificateId, ".cer"));
+
+                                using (FileStream fs = File.Create(certPath))
+                                {
+                                    int bytesRead;
+                                    byte[] buffer = new byte[1024 * 4];
+
+                                    while (0 != (bytesRead = digitalCertificateRecord.GetStream(2, buffer, buffer.Length)))
+                                    {
+                                        fs.Write(buffer, 0, bytesRead);
+                                    }
+                                }
+
+                                // Add it to our "add to MsiDigitalCertificate" table dictionary
+                                Row digitalCertificateRow = digitalCertificateTable.CreateRow(null);
+                                digitalCertificateRow[0] = certificateId;
+
+                                // Now set the file path on disk where this binary stream will be picked up at import time
+                                digitalCertificateRow[1] = string.Concat(certificateId, ".cer");
+
+                                // Load the cert to get it's thumbprint
+                                X509Certificate cert = X509Certificate.CreateFromCertFile(certPath);
+                                X509Certificate2 cert2 = new X509Certificate2(cert);
+
+                                certificates.Add(cert2.Thumbprint, certificateId);
+                            }
+                        }
+                    }
+                }
+
+                using (View mediaView = database.OpenExecuteView("SELECT * FROM `Media`"))
+                {
+                    while (true)
+                    {
+                        using (Record mediaRecord = mediaView.Fetch())
+                        {
+                            if (null == mediaRecord)
+                            {
+                                break;
+                            }
+
+                            X509Certificate2 cert2 = null;
+                            Row digitalSignatureRow = null;
+
+                            string cabName = mediaRecord.GetString(4); // get the name of the cab
+                            // If there is no cabinet or it's an internal cab, skip it.
+                            if (String.IsNullOrEmpty(cabName) || cabName.StartsWith("#", StringComparison.Ordinal))
+                            {
+                                continue;
+                            }
+
+                            string cabId = mediaRecord.GetString(1); // get the ID of the cab
+                            string cabPath = Path.Combine(Path.GetDirectoryName(databaseFile), cabName);
+
+                            // If the cabs aren't there, throw an error but continue to catch the other errors
+                            if (!File.Exists(cabPath))
+                            {
+                                this.OnMessage(WixErrors.WixFileNotFound(cabPath));
+                                continue;
+                            }
+
+                            try
+                            {
+                                // Get the certificate from the cab
+                                X509Certificate signedFileCert = X509Certificate.CreateFromSignedFile(cabPath);
+                                cert2 = new X509Certificate2(signedFileCert);
+                            }
+                            catch (System.Security.Cryptography.CryptographicException e)
+                            {
+                                uint HResult = unchecked((uint)Marshal.GetHRForException(e));
+
+                                // If the file has no cert, continue, but flag that we found at least one so we can later give a warning
+                                if (0x80092009 == HResult) // CRYPT_E_NO_MATCH
+                                {
+                                    foundUnsignedExternals = true;
+                                    continue;
+                                }
+
+                                // todo: exactly which HRESULT corresponds to this issue?
+                                // If it's one of these exact platforms, warn the user that it may be due to their OS.
+                                if ((5 == Environment.OSVersion.Version.Major && 2 == Environment.OSVersion.Version.Minor) || // W2K3
+                                        (5 == Environment.OSVersion.Version.Major && 1 == Environment.OSVersion.Version.Minor)) // XP
+                                {
+                                    this.OnMessage(WixErrors.UnableToGetAuthenticodeCertOfFileDownlevelOS(cabPath, String.Format(CultureInfo.InvariantCulture, "HRESULT: 0x{0:x8}", HResult)));
+                                }
+                                else // otherwise, generic error
+                                {
+                                    this.OnMessage(WixErrors.UnableToGetAuthenticodeCertOfFile(cabPath, String.Format(CultureInfo.InvariantCulture, "HRESULT: 0x{0:x8}", HResult)));
+                                }
+                            }
+
+                            // If we haven't added this cert to the MsiDigitalCertificate table, set it up to be added
+                            if (!certificates.ContainsKey(cert2.Thumbprint))
+                            {
+                                // generate a stable identifier
+                                string certificateGeneratedId = Common.GenerateIdentifier("cer", cert2.Thumbprint);
+
+                                // Add it to our "add to MsiDigitalCertificate" table dictionary
+                                Row digitalCertificateRow = digitalCertificateTable.CreateRow(null);
+                                digitalCertificateRow[0] = certificateGeneratedId;
+
+                                // Export to a file, because the MSI API's require us to provide a file path on disk
+                                string certPath = Path.Combine(this.TempFilesLocation, "MsiDigitalCertificate");
+                                Directory.CreateDirectory(certPath);
+                                certPath = Path.Combine(certPath, string.Concat(cert2.Thumbprint, ".cer"));
+                                File.Delete(certPath);
+
+                                using (BinaryWriter writer = new BinaryWriter(File.Open(certPath, FileMode.Create)))
+                                {
+                                    writer.Write(cert2.RawData);
+                                    writer.Close();
+                                }
+
+                                // Now set the file path on disk where this binary stream will be picked up at import time
+                                digitalCertificateRow[1] = string.Concat(cert2.Thumbprint, ".cer");
+
+                                certificates.Add(cert2.Thumbprint, certificateGeneratedId);
+                            }
+
+                            digitalSignatureRow = digitalSignatureTable.CreateRow(null);
+
+                            digitalSignatureRow[0] = "Media";
+                            digitalSignatureRow[1] = cabId;
+                            digitalSignatureRow[2] = certificates[cert2.Thumbprint];
+                        }
+                    }
+                }
+
+                if (digitalCertificateTable.Rows.Count > 0)
+                {
+                    database.ImportTable(codepage, digitalCertificateTable, this.TempFilesLocation, true);
+                    shouldCommit = true;
+                }
+
+                if (digitalSignatureTable.Rows.Count > 0)
+                {
+                    database.ImportTable(codepage, digitalSignatureTable, this.TempFilesLocation, true);
+                    shouldCommit = true;
+                }
+
+                // TODO: if we created the table(s), then we should add the _Validation records for them.
+
+                certificates = null;
+
+                // If we did find external cabs but none of them were signed, give a warning
+                if (foundUnsignedExternals)
+                {
+                    this.OnMessage(WixWarnings.ExternalCabsAreNotSigned(databaseFile));
+                }
+
+                if (shouldCommit)
+                {
+                    database.Commit();
+                }
+            }
+
+            return shouldCommit;
+        }
+
+        /// <summary>
+        /// Cleans up the temp files used by the Inscriber.
+        /// </summary>
+        /// <returns>True if all files were deleted, false otherwise.</returns>
+        public bool DeleteTempFiles()
+        {
+#if REDO_IN_NETCORE
+            if (null == this.tempFiles)
+            {
+                return true; // no work to do
+            }
+            else
+            {
+                bool deleted = Common.DeleteTempFiles(this.TempFilesLocation, this);
+
+                if (deleted)
+                {
+                    ((IDisposable)this.tempFiles).Dispose();
+                    this.tempFiles = null; // temp files have been deleted, no need to remember this now
+                }
+
+                return deleted;
+            }
+#endif
+            return true;
+        }
+
+        public void OnMessage(MessageEventArgs e)
+        {
+            Messaging.Instance.OnMessage(e);
+        }
+    }
+}
diff --git a/src/WixToolset.Core/InspectorCore.cs b/src/WixToolset.Core/InspectorCore.cs
new file mode 100644
index 00000000..63b6af6e
--- /dev/null
+++ b/src/WixToolset.Core/InspectorCore.cs
@@ -0,0 +1,32 @@
+// 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
+{
+    using System;
+    using WixToolset.Data;
+    using WixToolset.Extensibility;
+
+    /// <summary>
+    /// Core facilities for inspector extensions.
+    /// </summary>
+    internal sealed class InspectorCore : IInspectorCore
+    {
+        /// <summary>
+        /// Gets whether an error occured.
+        /// </summary>
+        /// <value>Whether an error occured.</value>
+        public bool EncounteredError
+        {
+            get { return Messaging.Instance.EncounteredError; }
+        }
+
+        /// <summary>
+        /// Logs a message to the log handler.
+        /// </summary>
+        /// <param name="e">The <see cref="MessageEventArgs"/> that contains information to log.</param>
+        public void OnMessage(MessageEventArgs e)
+        {
+            Messaging.Instance.OnMessage(e);
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Librarian.cs b/src/WixToolset.Core/Librarian.cs
new file mode 100644
index 00000000..daf53478
--- /dev/null
+++ b/src/WixToolset.Core/Librarian.cs
@@ -0,0 +1,95 @@
+// 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
+{
+    using System;
+    using System.Collections.Generic;
+    using WixToolset.Data;
+    using WixToolset.Extensibility;
+    using WixToolset.Link;
+
+    /// <summary>
+    /// Core librarian tool.
+    /// </summary>
+    public sealed class Librarian
+    {
+        /// <summary>
+        /// Instantiate a new Librarian class.
+        /// </summary>
+        public Librarian()
+        {
+            this.TableDefinitions = new TableDefinitionCollection(WindowsInstallerStandard.GetTableDefinitions());
+        }
+
+        /// <summary>
+        /// Gets table definitions used by this librarian.
+        /// </summary>
+        /// <value>Table definitions.</value>
+        public TableDefinitionCollection TableDefinitions { get; private set; }
+
+        /// <summary>
+        /// Adds an extension's data.
+        /// </summary>
+        /// <param name="extension">The extension data to add.</param>
+        public void AddExtensionData(IExtensionData extension)
+        {
+            if (null != extension.TableDefinitions)
+            {
+                foreach (TableDefinition tableDefinition in extension.TableDefinitions)
+                {
+                    try
+                    {
+                        this.TableDefinitions.Add(tableDefinition);
+                    }
+                    catch (ArgumentException)
+                    {
+                        Messaging.Instance.OnMessage(WixErrors.DuplicateExtensionTable(extension.GetType().ToString(), tableDefinition.Name));
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Create a library by combining several intermediates (objects).
+        /// </summary>
+        /// <param name="sections">The sections to combine into a library.</param>
+        /// <returns>Returns the new library.</returns>
+        public Library Combine(IEnumerable<Section> sections)
+        {
+            Library library = new Library(sections);
+
+            this.Validate(library);
+
+            return (Messaging.Instance.EncounteredError ? null : library);
+        }
+
+        /// <summary>
+        /// Sends a message to the message delegate if there is one.
+        /// </summary>
+        /// <param name="mea">Message event arguments.</param>
+        public void OnMessage(MessageEventArgs e)
+        {
+            Messaging.Instance.OnMessage(e);
+        }
+
+        /// <summary>
+        /// Validate that a library contains one entry section and no duplicate symbols.
+        /// </summary>
+        /// <param name="library">Library to validate.</param>
+        private void Validate(Library library)
+        {
+            FindEntrySectionAndLoadSymbolsCommand find = new FindEntrySectionAndLoadSymbolsCommand(library.Sections);
+            find.Execute();
+
+            // TODO: Consider bringing this sort of verification back.
+            // foreach (Section section in library.Sections)
+            // {
+            //     ResolveReferencesCommand resolve = new ResolveReferencesCommand(find.EntrySection, find.Symbols);
+            //     resolve.Execute();
+            //
+            //     ReportDuplicateResolvedSymbolErrorsCommand reportDupes = new ReportDuplicateResolvedSymbolErrorsCommand(find.SymbolsWithDuplicates, resolve.ResolvedSections);
+            //     reportDupes.Execute();
+            // }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Link/ConnectToFeature.cs b/src/WixToolset.Core/Link/ConnectToFeature.cs
new file mode 100644
index 00000000..6e046b89
--- /dev/null
+++ b/src/WixToolset.Core/Link/ConnectToFeature.cs
@@ -0,0 +1,95 @@
+// 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.Link
+{
+    using System.Collections.Specialized;
+    using WixToolset.Data;
+
+    /// <summary>
+    /// Object that connects things (components/modules) to features.
+    /// </summary>
+    public sealed class ConnectToFeature
+    {
+        private Section section;
+        private string childId;
+
+        private string primaryFeature;
+        private bool explicitPrimaryFeature;
+        private StringCollection connectFeatures;
+
+        /// <summary>
+        /// Creates a new connect to feature.
+        /// </summary>
+        /// <param name="section">Section this connect belongs to.</param>
+        /// <param name="childId">Id of the child.</param>
+        public ConnectToFeature(Section section, string childId) :
+            this(section, childId, null, false)
+        {
+        }
+
+        /// <summary>
+        /// Creates a new connect to feature.
+        /// </summary>
+        /// <param name="section">Section this connect belongs to.</param>
+        /// <param name="childId">Id of the child.</param>
+        /// <param name="primaryFeature">Sets the primary feature for the connection.</param>
+        /// <param name="explicitPrimaryFeature">Sets if this is explicit primary.</param>
+        public ConnectToFeature(Section section, string childId, string primaryFeature, bool explicitPrimaryFeature)
+        {
+            this.section = section;
+            this.childId = childId;
+
+            this.primaryFeature = primaryFeature;
+            this.explicitPrimaryFeature = explicitPrimaryFeature;
+
+            this.connectFeatures = new StringCollection();
+        }
+
+        /// <summary>
+        /// Gets the section.
+        /// </summary>
+        /// <value>Section.</value>
+        public Section Section
+        {
+            get { return this.section; }
+        }
+
+        /// <summary>
+        /// Gets the child identifier.
+        /// </summary>
+        /// <value>The child identifier.</value>
+        public string ChildId
+        {
+            get { return this.childId; }
+        }
+
+        /// <summary>
+        /// Gets or sets if the flag for if the primary feature was set explicitly.
+        /// </summary>
+        /// <value>The flag for if the primary feature was set explicitly.</value>
+        public bool IsExplicitPrimaryFeature
+        {
+            get { return this.explicitPrimaryFeature; }
+            set { this.explicitPrimaryFeature = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the primary feature.
+        /// </summary>
+        /// <value>The primary feature.</value>
+        public string PrimaryFeature
+        {
+            get { return this.primaryFeature; }
+            set { this.primaryFeature = value; }
+        }
+
+        /// <summary>
+        /// Gets the features connected to.
+        /// </summary>
+        /// <value>Features connected to.</value>
+        public StringCollection ConnectFeatures
+        {
+            get { return this.connectFeatures; }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Link/ConnectToFeatureCollection.cs b/src/WixToolset.Core/Link/ConnectToFeatureCollection.cs
new file mode 100644
index 00000000..8dd0d22c
--- /dev/null
+++ b/src/WixToolset.Core/Link/ConnectToFeatureCollection.cs
@@ -0,0 +1,92 @@
+// 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.Link
+{
+    using System;
+    using System.Collections;
+
+    /// <summary>
+    /// Hash collection of connect to feature objects.
+    /// </summary>
+    public sealed class ConnectToFeatureCollection : ICollection
+    {
+        private Hashtable collection;
+
+        /// <summary>
+        /// Instantiate a new ConnectToFeatureCollection class.
+        /// </summary>
+        public ConnectToFeatureCollection()
+        {
+            this.collection = new Hashtable();
+        }
+
+        /// <summary>
+        /// Gets the number of items in the collection.
+        /// </summary>
+        /// <value>Number of items in collection.</value>
+        public int Count
+        {
+            get { return this.collection.Count; }
+        }
+
+        /// <summary>
+        /// Gets if the collection has been synchronized.
+        /// </summary>
+        /// <value>True if the collection has been synchronized.</value>
+        public bool IsSynchronized
+        {
+            get { return this.collection.IsSynchronized; }
+        }
+
+        /// <summary>
+        /// Gets the object used to synchronize the collection.
+        /// </summary>
+        /// <value>Oject used the synchronize the collection.</value>
+        public object SyncRoot
+        {
+            get { return this.collection.SyncRoot; }
+        }
+
+        /// <summary>
+        /// Gets a feature connection by child id.
+        /// </summary>
+        /// <param name="childId">Identifier of child to locate.</param>
+        public ConnectToFeature this[string childId]
+        {
+            get { return (ConnectToFeature)this.collection[childId]; }
+        }
+
+        /// <summary>
+        /// Adds a feature connection to the collection.
+        /// </summary>
+        /// <param name="connection">Feature connection to add.</param>
+        public void Add(ConnectToFeature connection)
+        {
+            if (null == connection)
+            {
+                throw new ArgumentNullException("connection");
+            }
+
+            this.collection.Add(connection.ChildId, connection);
+        }
+
+        /// <summary>
+        /// Copies the collection into an array.
+        /// </summary>
+        /// <param name="array">Array to copy the collection into.</param>
+        /// <param name="index">Index to start copying from.</param>
+        public void CopyTo(System.Array array, int index)
+        {
+            this.collection.CopyTo(array, index);
+        }
+
+        /// <summary>
+        /// Gets enumerator for the collection.
+        /// </summary>
+        /// <returns>Enumerator for the collection.</returns>
+        public IEnumerator GetEnumerator()
+        {
+            return this.collection.Values.GetEnumerator();
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Link/ConnectToModule.cs b/src/WixToolset.Core/Link/ConnectToModule.cs
new file mode 100644
index 00000000..d6a8338e
--- /dev/null
+++ b/src/WixToolset.Core/Link/ConnectToModule.cs
@@ -0,0 +1,54 @@
+// 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.Link
+{
+    /// <summary>
+    /// Object that connects things to modules.
+    /// </summary>
+    public sealed class ConnectToModule
+    {
+        private string childId;
+        private string module;
+        private string moduleLanguage;
+
+        /// <summary>
+        /// Creates a new connect to module.
+        /// </summary>
+        /// <param name="childId">Id of the child.</param>
+        /// <param name="module">Id of the module.</param>
+        /// <param name="moduleLanguage">Language of the module.</param>
+        public ConnectToModule(string childId, string module, string moduleLanguage)
+        {
+            this.childId = childId;
+            this.module = module;
+            this.moduleLanguage = moduleLanguage;
+        }
+
+        /// <summary>
+        /// Gets the id of the child.
+        /// </summary>
+        /// <value>Child identifier.</value>
+        public string ChildId
+        {
+            get { return this.childId; }
+        }
+
+        /// <summary>
+        /// Gets the id of the module.
+        /// </summary>
+        /// <value>The id of the module.</value>
+        public string Module
+        {
+            get { return this.module; }
+        }
+
+        /// <summary>
+        /// Gets the language of the module.
+        /// </summary>
+        /// <value>The language of the module.</value>
+        public string ModuleLanguage
+        {
+            get { return this.moduleLanguage; }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Link/ConnectToModuleCollection.cs b/src/WixToolset.Core/Link/ConnectToModuleCollection.cs
new file mode 100644
index 00000000..6595487f
--- /dev/null
+++ b/src/WixToolset.Core/Link/ConnectToModuleCollection.cs
@@ -0,0 +1,92 @@
+// 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.Link
+{
+    using System;
+    using System.Collections;
+
+    /// <summary>
+    /// Hash collection of connect to module objects.
+    /// </summary>
+    public sealed class ConnectToModuleCollection : ICollection
+    {
+        private Hashtable collection;
+
+        /// <summary>
+        /// Instantiate a new ConnectToModuleCollection class.
+        /// </summary>
+        public ConnectToModuleCollection()
+        {
+            this.collection = new Hashtable();
+        }
+
+        /// <summary>
+        /// Gets the number of elements actually contained in the ConnectToModuleCollection.
+        /// </summary>
+        /// <value>The number of elements actually contained in the ConnectToModuleCollection.</value>
+        public int Count
+        {
+            get { return this.collection.Count; }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether access to the ConnectToModuleCollection is synchronized (thread-safe).
+        /// </summary>
+        /// <value>true if access to the ConnectToModuleCollection is synchronized (thread-safe); otherwise, false. The default is false.</value>
+        public bool IsSynchronized
+        {
+            get { return this.collection.IsSynchronized; }
+        }
+
+        /// <summary>
+        /// Gets an object that can be used to synchronize access to the ConnectToModuleCollection.
+        /// </summary>
+        /// <value>An object that can be used to synchronize access to the ConnectToModuleCollection.</value>
+        public object SyncRoot
+        {
+            get { return this.collection.SyncRoot; }
+        }
+
+        /// <summary>
+        /// Gets a module connection by child id.
+        /// </summary>
+        /// <param name="childId">Identifier of child to locate.</param>
+        public ConnectToModule this[string childId]
+        {
+            get { return (ConnectToModule)this.collection[childId]; }
+        }
+
+        /// <summary>
+        /// Adds a module connection to the collection.
+        /// </summary>
+        /// <param name="connection">Module connection to add.</param>
+        public void Add(ConnectToModule connection)
+        {
+            if (null == connection)
+            {
+                throw new ArgumentNullException("connection");
+            }
+
+            this.collection.Add(connection.ChildId, connection);
+        }
+
+        /// <summary>
+        /// Copies the entire ConnectToModuleCollection to a compatible one-dimensional Array, starting at the specified index of the target array.
+        /// </summary>
+        /// <param name="array">The one-dimensional Array that is the destination of the elements copied from this ConnectToModuleCollection. The Array must have zero-based indexing.</param>
+        /// <param name="index">The zero-based index in array at which copying begins.</param>
+        public void CopyTo(System.Array array, int index)
+        {
+            this.collection.Keys.CopyTo(array, index);
+        }
+
+        /// <summary>
+        /// Returns an enumerator for the entire ConnectToModuleCollection.
+        /// </summary>
+        /// <returns>An IEnumerator for the entire ConnectToModuleCollection.</returns>
+        public IEnumerator GetEnumerator()
+        {
+            return this.collection.Keys.GetEnumerator();
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Link/FindEntrySectionAndLoadSymbolsCommand.cs b/src/WixToolset.Core/Link/FindEntrySectionAndLoadSymbolsCommand.cs
new file mode 100644
index 00000000..effb06e4
--- /dev/null
+++ b/src/WixToolset.Core/Link/FindEntrySectionAndLoadSymbolsCommand.cs
@@ -0,0 +1,109 @@
+// 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.Link
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using WixToolset.Data;
+
+    internal class FindEntrySectionAndLoadSymbolsCommand : ICommand
+    {
+        private IEnumerable<Section> sections;
+
+        public FindEntrySectionAndLoadSymbolsCommand(IEnumerable<Section> sections)
+        {
+            this.sections = sections;
+        }
+
+        /// <summary>
+        /// Sets the expected entry output type, based on output file extension provided to the linker.
+        /// </summary>
+        public OutputType ExpectedOutputType { private get; set; }
+
+        /// <summary>
+        /// Gets the located entry section after the command is executed.
+        /// </summary>
+        public Section EntrySection { get; private set; }
+
+        /// <summary>
+        /// Gets the collection of loaded symbols.
+        /// </summary>
+        public IDictionary<string, Symbol> Symbols { get; private set; }
+
+        public IEnumerable<Symbol> PossiblyConflictingSymbols { get; private set; }
+
+        public void Execute()
+        {
+            Dictionary<string, Symbol> symbols = new Dictionary<string, Symbol>();
+            HashSet<Symbol> possibleConflicts = new HashSet<Symbol>();
+
+            SectionType expectedEntrySectionType;
+            if (!Enum.TryParse<SectionType>(this.ExpectedOutputType.ToString(), out expectedEntrySectionType))
+            {
+                expectedEntrySectionType = SectionType.Unknown;
+            }
+
+            foreach (Section section in this.sections)
+            {
+                // Try to find the one and only entry section.
+                if (SectionType.Product == section.Type || SectionType.Module == section.Type || SectionType.PatchCreation == section.Type || SectionType.Patch == section.Type || SectionType.Bundle == section.Type)
+                {
+                    if (SectionType.Unknown != expectedEntrySectionType && section.Type != expectedEntrySectionType)
+                    {
+                        string outputExtension = Output.GetExtension(this.ExpectedOutputType);
+                        Messaging.Instance.OnMessage(WixWarnings.UnexpectedEntrySection(section.SourceLineNumbers, section.Type.ToString(), expectedEntrySectionType.ToString(), outputExtension));
+                    }
+
+                    if (null == this.EntrySection)
+                    {
+                        this.EntrySection = section;
+                    }
+                    else
+                    {
+                        Messaging.Instance.OnMessage(WixErrors.MultipleEntrySections(this.EntrySection.SourceLineNumbers, this.EntrySection.Id, section.Id));
+                        Messaging.Instance.OnMessage(WixErrors.MultipleEntrySections2(section.SourceLineNumbers));
+                    }
+                }
+
+                // Load all the symbols from the section's tables that create symbols.
+                foreach (Table table in section.Tables.Where(t => t.Definition.CreateSymbols))
+                {
+                    foreach (Row row in table.Rows)
+                    {
+                        Symbol symbol = new Symbol(row);
+
+                        Symbol existingSymbol;
+                        if (!symbols.TryGetValue(symbol.Name, out existingSymbol))
+                        {
+                            symbols.Add(symbol.Name, symbol);
+                        }
+                        else // uh-oh, duplicate symbols.
+                        {
+                            // If the duplicate symbols are both private directories, there is a chance that they
+                            // point to identical rows. Identical directory rows are redundant and will not cause
+                            // conflicts.
+                            if (AccessModifier.Private == existingSymbol.Access && AccessModifier.Private == symbol.Access &&
+                                "Directory" == existingSymbol.Row.Table.Name && existingSymbol.Row.IsIdentical(symbol.Row))
+                            {
+                                // Ensure identical symbol's row is marked redundant to ensure (should the row be
+                                // referenced into the final output) it will not add duplicate primary keys during
+                                // the .IDT importing.
+                                symbol.Row.Redundant = true;
+                                existingSymbol.AddRedundant(symbol);
+                            }
+                            else
+                            {
+                                existingSymbol.AddPossibleConflict(symbol);
+                                possibleConflicts.Add(existingSymbol);
+                            }
+                        }
+                    }
+                }
+            }
+
+            this.Symbols = symbols;
+            this.PossiblyConflictingSymbols = possibleConflicts;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Link/ReportConflictingSymbolsCommand.cs b/src/WixToolset.Core/Link/ReportConflictingSymbolsCommand.cs
new file mode 100644
index 00000000..39c3a5c2
--- /dev/null
+++ b/src/WixToolset.Core/Link/ReportConflictingSymbolsCommand.cs
@@ -0,0 +1,49 @@
+// 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.Link
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using WixToolset.Data;
+
+    public class ReportConflictingSymbolsCommand : ICommand
+    {
+        private IEnumerable<Symbol> possibleConflicts;
+        private IEnumerable<Section> resolvedSections;
+
+        public ReportConflictingSymbolsCommand(IEnumerable<Symbol> possibleConflicts, IEnumerable<Section> resolvedSections)
+        {
+            this.possibleConflicts = possibleConflicts;
+            this.resolvedSections = resolvedSections;
+        }
+
+        public void Execute()
+        {
+            // Do a quick check if there are any possibly conflicting symbols that don't come from tables that allow
+            // overriding. Hopefully the symbols with possible conflicts list is usually very short list (empty should
+            // be the most common). If we find any matches, we'll do a more costly check to see if the possible conflicting
+            // symbols are in sections we actually referenced. From the resulting set, show an error for each duplicate
+            // (aka: conflicting) symbol. This should catch any rows with colliding primary keys (since symbols are based
+            // on the primary keys of rows).
+            List<Symbol> illegalDuplicates = possibleConflicts.Where(s => "WixAction" != s.Row.Table.Name && "WixVariable" != s.Row.Table.Name).ToList();
+            if (0 < illegalDuplicates.Count)
+            {
+                HashSet<Section> referencedSections = new HashSet<Section>(resolvedSections);
+                foreach (Symbol referencedDuplicateSymbol in illegalDuplicates.Where(s => referencedSections.Contains(s.Section)))
+                {
+                    List<Symbol> actuallyReferencedDuplicateSymbols = referencedDuplicateSymbol.PossiblyConflictingSymbols.Where(s => referencedSections.Contains(s.Section)).ToList();
+
+                    if (actuallyReferencedDuplicateSymbols.Any())
+                    {
+                        Messaging.Instance.OnMessage(WixErrors.DuplicateSymbol(referencedDuplicateSymbol.Row.SourceLineNumbers, referencedDuplicateSymbol.Name));
+
+                        foreach (Symbol duplicate in actuallyReferencedDuplicateSymbols)
+                        {
+                            Messaging.Instance.OnMessage(WixErrors.DuplicateSymbol2(duplicate.Row.SourceLineNumbers));
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Link/ResolveReferencesCommand.cs b/src/WixToolset.Core/Link/ResolveReferencesCommand.cs
new file mode 100644
index 00000000..5a985f3f
--- /dev/null
+++ b/src/WixToolset.Core/Link/ResolveReferencesCommand.cs
@@ -0,0 +1,178 @@
+// 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.Link
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Linq;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+
+    /// <summary>
+    /// Resolves all the simple references in a section.
+    /// </summary>
+    internal class ResolveReferencesCommand : ICommand
+    {
+        private Section entrySection;
+        private IDictionary<string, Symbol> symbols;
+        private HashSet<Symbol> referencedSymbols;
+        private HashSet<Section> resolvedSections;
+
+        public ResolveReferencesCommand(Section entrySection, IDictionary<string, Symbol> symbols)
+        {
+            this.entrySection = entrySection;
+            this.symbols = symbols;
+        }
+
+        public bool BuildingMergeModule { private get; set; }
+
+        public IEnumerable<Symbol> ReferencedSymbols { get { return this.referencedSymbols; } }
+
+        public IEnumerable<Section> ResolvedSections { get { return this.resolvedSections; } }
+
+        /// <summary>
+        /// Resolves all the simple references in a section.
+        /// </summary>
+        public void Execute()
+        {
+            this.resolvedSections = new HashSet<Section>();
+            this.referencedSymbols = new HashSet<Symbol>();
+
+            this.RecursivelyResolveReferences(this.entrySection);
+        }
+
+        /// <summary>
+        /// Recursive helper function to resolve all references of passed in section.
+        /// </summary>
+        /// <param name="section">Section with references to resolve.</param>
+        /// <remarks>Note: recursive function.</remarks>
+        private void RecursivelyResolveReferences(Section section)
+        {
+            // If we already resolved this section, move on to the next.
+            if (!this.resolvedSections.Add(section))
+            {
+                return;
+            }
+
+            // Process all of the references contained in this section using the collection of
+            // symbols provided.  Then recursively call this method to process the
+            // located symbol's section.  All in all this is a very simple depth-first
+            // search of the references per-section.
+            Table wixSimpleReferenceTable;
+            if (section.Tables.TryGetTable("WixSimpleReference", out wixSimpleReferenceTable))
+            {
+                foreach (WixSimpleReferenceRow wixSimpleReferenceRow in wixSimpleReferenceTable.Rows)
+                {
+                    Debug.Assert(wixSimpleReferenceRow.Section == section);
+
+                    // If we're building a Merge Module, ignore all references to the Media table
+                    // because Merge Modules don't have Media tables.
+                    if (this.BuildingMergeModule && "Media" == wixSimpleReferenceRow.TableName)
+                    {
+                        continue;
+                    }
+
+                    Symbol symbol;
+                    if (!this.symbols.TryGetValue(wixSimpleReferenceRow.SymbolicName, out symbol))
+                    {
+                        Messaging.Instance.OnMessage(WixErrors.UnresolvedReference(wixSimpleReferenceRow.SourceLineNumbers, wixSimpleReferenceRow.SymbolicName));
+                    }
+                    else // see if the symbol (and any of its duplicates) are appropriately accessible.
+                    {
+                        IList<Symbol> accessible = DetermineAccessibleSymbols(section, symbol);
+                        if (!accessible.Any())
+                        {
+                            Messaging.Instance.OnMessage(WixErrors.UnresolvedReference(wixSimpleReferenceRow.SourceLineNumbers, wixSimpleReferenceRow.SymbolicName, symbol.Access));
+                        }
+                        else if (1 == accessible.Count)
+                        {
+                            Symbol accessibleSymbol = accessible[0];
+                            this.referencedSymbols.Add(accessibleSymbol);
+
+                            if (null != accessibleSymbol.Section)
+                            {
+                                RecursivelyResolveReferences(accessibleSymbol.Section);
+                            }
+                        }
+                        else // display errors for the duplicate symbols.
+                        {
+                            Symbol accessibleSymbol = accessible[0];
+                            string referencingSourceLineNumber = wixSimpleReferenceRow.SourceLineNumbers.ToString();
+                            if (String.IsNullOrEmpty(referencingSourceLineNumber))
+                            {
+                                Messaging.Instance.OnMessage(WixErrors.DuplicateSymbol(accessibleSymbol.Row.SourceLineNumbers, accessibleSymbol.Name));
+                            }
+                            else
+                            {
+                                Messaging.Instance.OnMessage(WixErrors.DuplicateSymbol(accessibleSymbol.Row.SourceLineNumbers, accessibleSymbol.Name, referencingSourceLineNumber));
+                            }
+
+                            foreach (Symbol accessibleDuplicate in accessible.Skip(1))
+                            {
+                                Messaging.Instance.OnMessage(WixErrors.DuplicateSymbol2(accessibleDuplicate.Row.SourceLineNumbers));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Determine if the symbol and any of its duplicates are accessbile by referencing section.
+        /// </summary>
+        /// <param name="referencingSection">Section referencing the symbol.</param>
+        /// <param name="symbol">Symbol being referenced.</param>
+        /// <returns>List of symbols accessible by referencing section.</returns>
+        private IList<Symbol> DetermineAccessibleSymbols(Section referencingSection, Symbol symbol)
+        {
+            List<Symbol> symbols = new List<Symbol>();
+
+            if (AccessibleSymbol(referencingSection, symbol))
+            {
+                symbols.Add(symbol);
+            }
+
+            foreach (Symbol dupe in symbol.PossiblyConflictingSymbols)
+            {
+                if (AccessibleSymbol(referencingSection, dupe))
+                {
+                    symbols.Add(dupe);
+                }
+            }
+
+            foreach (Symbol dupe in symbol.RedundantSymbols)
+            {
+                if (AccessibleSymbol(referencingSection, dupe))
+                {
+                    symbols.Add(dupe);
+                }
+            }
+
+            return symbols;
+        }
+
+        /// <summary>
+        /// Determine if a single symbol is accessible by the referencing section.
+        /// </summary>
+        /// <param name="referencingSection">Section referencing the symbol.</param>
+        /// <param name="symbol">Symbol being referenced.</param>
+        /// <returns>True if symbol is accessible.</returns>
+        private bool AccessibleSymbol(Section referencingSection, Symbol symbol)
+        {
+            switch (symbol.Access)
+            {
+                case AccessModifier.Public:
+                    return true;
+                case AccessModifier.Internal:
+                    return symbol.Row.Section.IntermediateId.Equals(referencingSection.IntermediateId) || (null != symbol.Row.Section.LibraryId && symbol.Row.Section.LibraryId.Equals(referencingSection.LibraryId));
+                case AccessModifier.Protected:
+                    return symbol.Row.Section.IntermediateId.Equals(referencingSection.IntermediateId);
+                case AccessModifier.Private:
+                    return referencingSection == symbol.Section;
+                default:
+                    throw new InvalidOperationException();
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Link/WixGroupingOrdering.cs b/src/WixToolset.Core/Link/WixGroupingOrdering.cs
new file mode 100644
index 00000000..fc0ce43b
--- /dev/null
+++ b/src/WixToolset.Core/Link/WixGroupingOrdering.cs
@@ -0,0 +1,726 @@
+// 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.Link
+{
+    using System;
+    using System.Collections;
+    using System.Collections.ObjectModel;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.Globalization;
+    using System.Linq;
+    using System.Text;
+    using WixToolset.Extensibility;
+    using WixToolset.Data;
+
+    /// <summary>
+    /// Grouping and Ordering class of the WiX toolset.
+    /// </summary>
+    internal sealed class WixGroupingOrdering : IMessageHandler
+    {
+        private Output output;
+        private IMessageHandler messageHandler;
+        private List<string> groupTypes;
+        private List<string> itemTypes;
+        private ItemCollection items;
+        private List<int> rowsUsed;
+        private bool loaded;
+        private bool encounteredError;
+
+        /// <summary>
+        /// Creates a WixGroupingOrdering object.
+        /// </summary>
+        /// <param name="output">Output from which to read the group and order information.</param>
+        /// <param name="messageHandler">Handler for any error messages.</param>
+        /// <param name="groupTypes">Group types to include.</param>
+        /// <param name="itemTypes">Item types to include.</param>
+        public WixGroupingOrdering(Output output, IMessageHandler messageHandler)
+        {
+            this.output = output;
+            this.messageHandler = messageHandler;
+
+            this.rowsUsed = new List<int>();
+            this.loaded = false;
+            this.encounteredError = false;
+        }
+
+        /// <summary>
+        /// Switches a WixGroupingOrdering object to operate on a new set of groups/items.
+        /// </summary>
+        /// <param name="groupTypes">Group types to include.</param>
+        /// <param name="itemTypes">Item types to include.</param>
+        public void UseTypes(IEnumerable<string> groupTypes, IEnumerable<string> itemTypes)
+        {
+            this.groupTypes = new List<string>(groupTypes);
+            this.itemTypes = new List<string>(itemTypes);
+
+            this.items = new ItemCollection();
+            this.loaded = false;
+        }
+
+        /// <summary>
+        /// Sends a message to the message handler if there is one.
+        /// </summary>
+        /// <param name="mea">Message event arguments.</param>
+        public void OnMessage(MessageEventArgs e)
+        {
+            WixErrorEventArgs errorEventArgs = e as WixErrorEventArgs;
+
+            if (null != errorEventArgs || MessageLevel.Error == e.Level)
+            {
+                this.encounteredError = true;
+            }
+
+            if (null != this.messageHandler)
+            {
+                this.messageHandler.OnMessage(e);
+            }
+            else if (null != errorEventArgs)
+            {
+                throw new WixException(errorEventArgs);
+            }
+        }
+
+        /// <summary>
+        /// Finds all nested items under a parent group and creates new WixGroup data for them.
+        /// </summary>
+        /// <param name="parentType">The group type for the parent group to flatten.</param>
+        /// <param name="parentId">The identifier of the parent group to flatten.</param>
+        /// <param name="removeUsedRows">Whether to remove used group rows before returning.</param>
+        public void FlattenAndRewriteRows(string parentType, string parentId, bool removeUsedRows)
+        {
+            Debug.Assert(this.groupTypes.Contains(parentType));
+
+            List<Item> orderedItems;
+            this.CreateOrderedList(parentType, parentId, out orderedItems);
+            if (this.encounteredError)
+            {
+                return;
+            }
+
+            this.CreateNewGroupRows(parentType, parentId, orderedItems);
+
+            if (removeUsedRows)
+            {
+                this.RemoveUsedGroupRows();
+            }
+        }
+
+        /// <summary>
+        /// Finds all items under a parent group type and creates new WixGroup data for them.
+        /// </summary>
+        /// <param name="parentType">The type of the parent group to flatten.</param>
+        /// <param name="removeUsedRows">Whether to remove used group rows before returning.</param>
+        public void FlattenAndRewriteGroups(string parentType, bool removeUsedRows)
+        {
+            Debug.Assert(this.groupTypes.Contains(parentType));
+
+            this.LoadFlattenOrderGroups();
+            if (this.encounteredError)
+            {
+                return;
+            }
+
+            foreach (Item item in this.items)
+            {
+                if (parentType == item.Type)
+                {
+                    List<Item> orderedItems;
+                    this.CreateOrderedList(item.Type, item.Id, out orderedItems);
+                    this.CreateNewGroupRows(item.Type, item.Id, orderedItems);
+                }
+            }
+
+            if (removeUsedRows)
+            {
+                this.RemoveUsedGroupRows();
+            }
+        }
+
+
+        /// <summary>
+        /// Creates a flattened and ordered list of items for the given parent group.
+        /// </summary>
+        /// <param name="parentType">The group type for the parent group to flatten.</param>
+        /// <param name="parentId">The identifier of the parent group to flatten.</param>
+        /// <param name="orderedItems">The returned list of ordered items.</param>
+        private void CreateOrderedList(string parentType, string parentId, out List<Item> orderedItems)
+        {
+            orderedItems = null;
+
+            this.LoadFlattenOrderGroups();
+            if (this.encounteredError)
+            {
+                return;
+            }
+
+            Item parentItem;
+            if (!this.items.TryGetValue(parentType, parentId, out parentItem))
+            {
+                this.OnMessage(WixErrors.IdentifierNotFound(parentType, parentId));
+                return;
+            }
+
+            orderedItems = new List<Item>(parentItem.ChildItems);
+            orderedItems.Sort(new Item.AfterItemComparer());
+        }
+
+        /// <summary>
+        /// Removes rows from WixGroup that have been used by this object.
+        /// </summary>
+        public void RemoveUsedGroupRows()
+        {
+            List<int> sortedIndexes = this.rowsUsed.Distinct().OrderByDescending(i => i).ToList();
+
+            Table wixGroupTable = this.output.Tables["WixGroup"];
+            Debug.Assert(null != wixGroupTable);
+            Debug.Assert(sortedIndexes[0] < wixGroupTable.Rows.Count);
+
+            foreach (int rowIndex in sortedIndexes)
+            {
+                wixGroupTable.Rows.RemoveAt(rowIndex);
+            }
+        }
+
+        /// <summary>
+        /// Creates new WixGroup rows for a list of items.
+        /// </summary>
+        /// <param name="parentType">The group type for the parent group in the new rows.</param>
+        /// <param name="parentId">The identifier of the parent group in the new rows.</param>
+        /// <param name="orderedItems">The list of new items.</param>
+        private void CreateNewGroupRows(string parentType, string parentId, List<Item> orderedItems)
+        {
+            // TODO: MSIs don't guarantee that rows stay in the same order, and technically, neither
+            // does WiX (although they do, currently). We probably want to "upgrade" this to a new
+            // table that includes a sequence number, and then change the code that uses ordered
+            // groups to read from that table instead.
+            Table wixGroupTable = this.output.Tables["WixGroup"];
+            Debug.Assert(null != wixGroupTable);
+
+            foreach (Item item in orderedItems)
+            {
+                Row row = wixGroupTable.CreateRow(item.Row.SourceLineNumbers);
+                row[0] = parentId;
+                row[1] = parentType;
+                row[2] = item.Id;
+                row[3] = item.Type;
+            }
+        }
+
+        // Group/Ordering Flattening Logic
+        //
+        // What follows is potentially convoluted logic. Two somewhat orthogonal concepts are in
+        // play: grouping (parent/child relationships) and ordering (before/after relationships).
+        // Dealing with just one or the other is straghtforward. Groups can be flattened
+        // recursively. Ordering can be propagated in either direction. When the ordering also
+        // participates in the grouping constructions, however, things get trickier.  For the
+        // purposes of this discussion, we're dealing with "items" and "groups", and an instance
+        // of either of them can be marked as coming "after" some other instance.
+        //
+        // For simple item-to-item ordering, the "after" values simply propagate: if A is after B,
+        // and B is after C, then we can say that A is after *both* B and C.  If a group is involved,
+        // it acts as a proxy for all of its included items and any sub-groups.
+
+        /// <summary>
+        /// Internal workhorse for ensuring that group and ordering information has
+        /// been loaded and applied.
+        /// </summary>
+        private void LoadFlattenOrderGroups()
+        {
+            if (!this.loaded)
+            {
+                this.LoadGroups();
+                this.LoadOrdering();
+
+                // It would be really nice to have a "find circular after dependencies"
+                // function, but it gets much more complicated because of the way that
+                // the dependencies are propagated across group boundaries. For now, we
+                // just live with the dependency loop detection as we flatten the
+                // dependencies. Group references, however, we can check directly.
+                this.FindCircularGroupReferences();
+
+                if (!this.encounteredError)
+                {
+                    this.FlattenGroups();
+                    this.FlattenOrdering();
+                }
+
+                this.loaded = true;
+            }
+        }
+
+        /// <summary>
+        /// Loads data from the WixGroup table.
+        /// </summary>
+        private void LoadGroups()
+        {
+            Table wixGroupTable = this.output.Tables["WixGroup"];
+            if (null == wixGroupTable || 0 == wixGroupTable.Rows.Count)
+            {
+                // TODO: Change message name to make it *not* Bundle specific?
+                this.OnMessage(WixErrors.MissingBundleInformation("WixGroup"));
+            }
+
+            // Collect all of the groups
+            for (int rowIndex = 0; rowIndex < wixGroupTable.Rows.Count; ++rowIndex)
+            {
+                Row row = wixGroupTable.Rows[rowIndex];
+                string rowParentName = (string)row[0];
+                string rowParentType = (string)row[1];
+                string rowChildName = (string)row[2];
+                string rowChildType = (string)row[3];
+
+                // If this row specifies a parent or child type that's not in our
+                // lists, we assume it's not a row that we're concerned about.
+                if (!this.groupTypes.Contains(rowParentType) ||
+                    !this.itemTypes.Contains(rowChildType))
+                {
+                    continue;
+                }
+
+                this.rowsUsed.Add(rowIndex);
+
+                Item parentItem;
+                if (!this.items.TryGetValue(rowParentType, rowParentName, out parentItem))
+                {
+                    parentItem = new Item(row, rowParentType, rowParentName);
+                    this.items.Add(parentItem);
+                }
+
+                Item childItem;
+                if (!this.items.TryGetValue(rowChildType, rowChildName, out childItem))
+                {
+                    childItem = new Item(row, rowChildType, rowChildName);
+                    this.items.Add(childItem);
+                }
+
+                parentItem.ChildItems.Add(childItem);
+            }
+        }
+
+        /// <summary>
+        /// Flattens group/item information.
+        /// </summary>
+        private void FlattenGroups()
+        {
+            foreach (Item item in this.items)
+            {
+                item.FlattenChildItems();
+            }
+        }
+
+        /// <summary>
+        /// Finds and reports circular references in the group/item data.
+        /// </summary>
+        private void FindCircularGroupReferences()
+        {
+            ItemCollection itemsInKnownLoops = new ItemCollection();
+            foreach (Item item in this.items)
+            {
+                if (itemsInKnownLoops.Contains(item))
+                {
+                    continue;
+                }
+
+                ItemCollection itemsSeen = new ItemCollection();
+                string circularReference;
+                if (this.FindCircularGroupReference(item, item, itemsSeen, out circularReference))
+                {
+                    itemsInKnownLoops.Add(itemsSeen);
+                    this.OnMessage(WixErrors.ReferenceLoopDetected(item.Row.SourceLineNumbers, circularReference));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Recursive worker to find and report circular references in group/item data.
+        /// </summary>
+        /// <param name="checkItem">The sentinal item being checked.</param>
+        /// <param name="currentItem">The current item in the recursion.</param>
+        /// <param name="itemsSeen">A list of all items already visited (for performance).</param>
+        /// <param name="circularReference">A list of items in the current circular reference, if one was found; null otherwise.</param>
+        /// <returns>True if a circular reference was found; false otherwise.</returns>
+        private bool FindCircularGroupReference(Item checkItem, Item currentItem, ItemCollection itemsSeen, out string circularReference)
+        {
+            circularReference = null;
+            foreach (Item subitem in currentItem.ChildItems)
+            {
+                if (checkItem == subitem)
+                {
+                    // TODO: Even better would be to include the source lines for each reference!
+                    circularReference = String.Format(CultureInfo.InvariantCulture, "{0}:{1} -> {2}:{3}",
+                        currentItem.Type, currentItem.Id, subitem.Type, subitem.Id);
+                    return true;
+                }
+
+                if (!itemsSeen.Contains(subitem))
+                {
+                    itemsSeen.Add(subitem);
+                    if (this.FindCircularGroupReference(checkItem, subitem, itemsSeen, out circularReference))
+                    {
+                        // TODO: Even better would be to include the source lines for each reference!
+                        circularReference = String.Format(CultureInfo.InvariantCulture, "{0}:{1} -> {2}",
+                            currentItem.Type, currentItem.Id, circularReference);
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Loads ordering dependency data from the WixOrdering table.
+        /// </summary>
+        private void LoadOrdering()
+        {
+            Table wixOrderingTable = output.Tables["WixOrdering"];
+            if (null == wixOrderingTable || 0 == wixOrderingTable.Rows.Count)
+            {
+                // TODO: Do we need a message here?
+                return;
+            }
+
+            foreach (Row row in wixOrderingTable.Rows)
+            {
+                string rowItemType = (string)row[0];
+                string rowItemName = (string)row[1];
+                string rowDependsOnType = (string)row[2];
+                string rowDependsOnName = (string)row[3];
+
+                // If this row specifies some other (unknown) type in either
+                // position, we assume it's not a row that we're concerned about.
+                // For ordering, we allow group and item in either position.
+                if (!(this.groupTypes.Contains(rowItemType) || this.itemTypes.Contains(rowItemType)) ||
+                    !(this.groupTypes.Contains(rowDependsOnType) || this.itemTypes.Contains(rowDependsOnType)))
+                {
+                    continue;
+                }
+
+                Item item = null;
+                Item dependsOn = null;
+
+                if (!this.items.TryGetValue(rowItemType, rowItemName, out item))
+                {
+                    this.OnMessage(WixErrors.IdentifierNotFound(rowItemType, rowItemName));
+                }
+
+                if (!this.items.TryGetValue(rowDependsOnType, rowDependsOnName, out dependsOn))
+                {
+                    this.OnMessage(WixErrors.IdentifierNotFound(rowDependsOnType, rowDependsOnName));
+                }
+
+                if (null == item || null == dependsOn)
+                {
+                    continue;
+                }
+
+                item.AddAfter(dependsOn, this);
+            }
+        }
+
+        /// <summary>
+        /// Flattens the ordering dependencies in the groups/items.
+        /// </summary>
+        private void FlattenOrdering()
+        {
+            // Because items don't know about their parent groups (and can, in fact, be
+            // in more than one group at a time), we need to pre-propagate the 'afters'
+            // from each parent item to its children before we attempt to flatten the
+            // ordering.
+            foreach (Item item in this.items)
+            {
+                item.PropagateAfterToChildItems(this);
+            }
+
+            foreach (Item item in this.items)
+            {
+                item.FlattenAfters(this);
+            }
+        }
+
+        /// <summary>
+        /// A variant of KeyedCollection that doesn't throw when an item is re-added.
+        /// </summary>
+        /// <typeparam name="TKey">Key type for the collection.</typeparam>
+        /// <typeparam name="TItem">Item type for the colelction.</typeparam>
+        internal abstract class EnhancedKeyCollection<TKey, TItem> : KeyedCollection<TKey, TItem>
+        {
+            new public void Add(TItem item)
+            {
+                if (!this.Contains(item))
+                {
+                    base.Add(item);
+                }
+            }
+
+            public void Add(Collection<TItem> list)
+            {
+                foreach (TItem item in list)
+                {
+                    this.Add(item);
+                }
+            }
+
+            public void Remove(Collection<TItem> list)
+            {
+                foreach (TItem item in list)
+                {
+                    this.Remove(item);
+                }
+            }
+
+            public bool TryGetValue(TKey key, out TItem item)
+            {
+                // KeyedCollection doesn't implement the TryGetValue() method, but it's
+                // a useful concept.  We can't just always pass this to the enclosed
+                // Dictionary, however, because it doesn't always exist! If it does, we
+                // can delegate to it as one would expect. If it doesn't, we have to
+                // implement everything ourselves in terms of Contains().
+
+                if (null != this.Dictionary)
+                {
+                    return this.Dictionary.TryGetValue(key, out item);
+                }
+
+                if (this.Contains(key))
+                {
+                    item = this[key];
+                    return true;
+                }
+
+                item = default(TItem);
+                return false;
+            }
+
+#if DEBUG
+            // This just makes debugging easier...
+            public override string ToString()
+            {
+                StringBuilder sb = new StringBuilder();
+                foreach (TItem item in this)
+                {
+                    sb.AppendFormat("{0}, ", item);
+                }
+                sb.Length -= 2;
+                return sb.ToString();
+            }
+#endif // DEBUG
+        }
+
+        /// <summary>
+        /// A specialized EnhancedKeyCollection, typed to Items.
+        /// </summary>
+        internal class ItemCollection : EnhancedKeyCollection<string, Item>
+        {
+            protected override string GetKeyForItem(Item item)
+            {
+                return item.Key;
+            }
+
+            public bool TryGetValue(string type, string id, out Item item)
+            {
+                return this.TryGetValue(CreateKeyFromTypeId(type, id), out item);
+            }
+
+            public static string CreateKeyFromTypeId(string type, string id)
+            {
+                return String.Format(CultureInfo.InvariantCulture, "{0}_{1}", type, id);
+            }
+        }
+
+        /// <summary>
+        /// An item (or group) in the grouping/ordering engine.
+        /// </summary>
+        /// <remarks>Encapsulates nested group membership and also before/after
+        /// ordering dependencies.</remarks>
+        internal class Item
+        {
+            private ItemCollection afterItems;
+            private ItemCollection beforeItems; // for checking for circular references
+            private bool flattenedAfterItems;
+
+            public Item(Row row, string type, string id)
+            {
+                this.Row = row;
+                this.Type = type;
+                this.Id = id;
+
+                this.Key = ItemCollection.CreateKeyFromTypeId(type, id);
+
+                afterItems = new ItemCollection();
+                beforeItems = new ItemCollection();
+                flattenedAfterItems = false;
+            }
+
+            public Row Row { get; private set; }
+            public string Type { get; private set; }
+            public string Id { get; private set; }
+            public string Key { get; private set; }
+
+#if DEBUG
+            // Makes debugging easier...
+            public override string ToString()
+            {
+                return this.Key;
+            }
+#endif // DEBUG
+
+            private ItemCollection childItems = new ItemCollection();
+            public ItemCollection ChildItems { get { return childItems; } }
+
+            /// <summary>
+            /// Removes any nested groups under this item and replaces
+            /// them with their child items.
+            /// </summary>
+            public void FlattenChildItems()
+            {
+                ItemCollection flattenedChildItems = new ItemCollection();
+
+                foreach (Item childItem in this.ChildItems)
+                {
+                    if (0 == childItem.ChildItems.Count)
+                    {
+                        flattenedChildItems.Add(childItem);
+                    }
+                    else
+                    {
+                        childItem.FlattenChildItems();
+                        flattenedChildItems.Add(childItem.ChildItems);
+                    }
+                }
+
+                this.ChildItems.Clear();
+                this.ChildItems.Add(flattenedChildItems);
+            }
+
+            /// <summary>
+            /// Adds a list of items to the 'after' ordering collection.
+            /// </summary>
+            /// <param name="items">List of items to add.</param>
+            /// <param name="messageHandler">Message handler in case a circular ordering reference is found.</param>
+            public void AddAfter(ItemCollection items, IMessageHandler messageHandler)
+            {
+                foreach (Item item in items)
+                {
+                    this.AddAfter(item, messageHandler);
+                }
+            }
+
+            /// <summary>
+            /// Adds an item to the 'after' ordering collection.
+            /// </summary>
+            /// <param name="item">Items to add.</param>
+            /// <param name="messageHandler">Message handler in case a circular ordering reference is found.</param>
+            public void AddAfter(Item after, IMessageHandler messageHandler)
+            {
+                if (this.beforeItems.Contains(after))
+                {
+                    // We could try to chain this up (the way that group circular dependencies
+                    // are reported), but since we're in the process of flattening, we may already
+                    // have lost some distinction between authored and propagated ordering.
+                    string circularReference = String.Format(CultureInfo.InvariantCulture, "{0}:{1} -> {2}:{3} -> {0}:{1}",
+                        this.Type, this.Id, after.Type, after.Id);
+                    messageHandler.OnMessage(WixErrors.OrderingReferenceLoopDetected(after.Row.SourceLineNumbers, circularReference));
+                    return;
+                }
+
+                this.afterItems.Add(after);
+                after.beforeItems.Add(this);
+            }
+
+            /// <summary>
+            /// Propagates 'after' dependencies from an item to its child items.
+            /// </summary>
+            /// <param name="messageHandler">Message handler in case a circular ordering reference is found.</param>
+            /// <remarks>Because items don't know about their parent groups (and can, in fact, be in more
+            /// than one group at a time), we need to propagate the 'afters' from each parent item to its children
+            /// before we attempt to flatten the ordering.</remarks>
+            public void PropagateAfterToChildItems(IMessageHandler messageHandler)
+            {
+                if (this.ShouldItemPropagateChildOrdering())
+                {
+                    foreach (Item childItem in this.childItems)
+                    {
+                        childItem.AddAfter(this.afterItems, messageHandler);
+                    }
+                }
+            }
+
+            /// <summary>
+            /// Flattens the ordering dependency for this item.
+            /// </summary>
+            /// <param name="messageHandler">Message handler in case a circular ordering reference is found.</param>
+            public void FlattenAfters(IMessageHandler messageHandler)
+            {
+                if (this.flattenedAfterItems)
+                {
+                    return;
+                }
+
+                this.flattenedAfterItems = true;
+
+                // Ensure that if we're after something (A), and *it's* after something (B),
+                // that we list ourselved as after both (A) *and* (B).
+                ItemCollection nestedAfterItems = new ItemCollection();
+
+                foreach (Item afterItem in this.afterItems)
+                {
+                    afterItem.FlattenAfters(messageHandler);
+                    nestedAfterItems.Add(afterItem.afterItems);
+
+                    if (afterItem.ShouldItemPropagateChildOrdering())
+                    {
+                        // If we are after a group, it really means
+                        // we are after all of the group's children.
+                        foreach (Item childItem in afterItem.ChildItems)
+                        {
+                            childItem.FlattenAfters(messageHandler);
+                            nestedAfterItems.Add(childItem.afterItems);
+                            nestedAfterItems.Add(childItem);
+                        }
+                    }
+                }
+
+                this.AddAfter(nestedAfterItems, messageHandler);
+            }
+
+            // We *don't* propagate ordering information from Packages or
+            // Containers to their children, because ordering doesn't matter
+            // for them, and a Payload in two Packages (or Containers) can
+            // cause a circular reference to occur.  We do, however, need to
+            // track the ordering in the UX Container, because we need the
+            // first payload to be the entrypoint.
+            private bool ShouldItemPropagateChildOrdering()
+            {
+                if (String.Equals("Package", this.Type, StringComparison.Ordinal) ||
+                    (String.Equals("Container", this.Type, StringComparison.Ordinal) &&
+                    !String.Equals(Compiler.BurnUXContainerId, this.Id, StringComparison.Ordinal)))
+                {
+                    return false;
+                }
+                return true;
+            }
+
+            /// <summary>
+            /// Helper IComparer class to make ordering easier.
+            /// </summary>
+            internal sealed class AfterItemComparer : IComparer<Item>
+            {
+                public int Compare(Item x, Item y)
+                {
+                    if (x.afterItems.Contains(y))
+                    {
+                        return 1;
+                    }
+                    else if (y.afterItems.Contains(x))
+                    {
+                        return -1;
+                    }
+
+                    return string.CompareOrdinal(x.Id, y.Id);
+                }
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Linker.cs b/src/WixToolset.Core/Linker.cs
new file mode 100644
index 00000000..166894b9
--- /dev/null
+++ b/src/WixToolset.Core/Linker.cs
@@ -0,0 +1,2434 @@
+// 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
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Collections.Specialized;
+    using System.Diagnostics;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Globalization;
+    using System.Linq;
+    using System.Text;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+    using WixToolset.Extensibility;
+    using WixToolset.Link;
+    using WixToolset.Core.Native;
+
+    /// <summary>
+    /// Linker core of the WiX toolset.
+    /// </summary>
+    public sealed class Linker : IMessageHandler
+    {
+        private static readonly char[] colonCharacter = ":".ToCharArray();
+        private static readonly string emptyGuid = Guid.Empty.ToString("B");
+
+        private List<IExtensionData> extensionData;
+
+        private List<InspectorExtension> inspectorExtensions;
+        private bool sectionIdOnRows;
+        private WixActionRowCollection standardActions;
+        private Localizer localizer;
+        private Output activeOutput;
+        private TableDefinitionCollection tableDefinitions;
+
+        /// <summary>
+        /// Creates a linker.
+        /// </summary>
+        public Linker()
+        {
+            this.sectionIdOnRows = true; // TODO: what is the correct value for this?
+
+            this.standardActions = WindowsInstallerStandard.GetStandardActions();
+            this.tableDefinitions = new TableDefinitionCollection(WindowsInstallerStandard.GetTableDefinitions());
+
+            this.extensionData = new List<IExtensionData>();
+            this.inspectorExtensions = new List<InspectorExtension>();
+        }
+
+        /// <summary>
+        /// Gets or sets the localizer.
+        /// </summary>
+        /// <value>The localizer.</value>
+        public Localizer Localizer
+        {
+            get { return this.localizer; }
+            set { this.localizer = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the path to output unreferenced symbols to. If null or empty, there is no output.
+        /// </summary>
+        /// <value>The path to output the xml file.</value>
+        public string UnreferencedSymbolsFile { get; set; }
+
+        /// <summary>
+        /// Gets or sets the option to show pedantic messages.
+        /// </summary>
+        /// <value>The option to show pedantic messages.</value>
+        public bool ShowPedanticMessages { get; set; }
+
+        /// <summary>
+        /// Gets the table definitions used by the linker.
+        /// </summary>
+        /// <value>Table definitions used by the linker.</value>
+        public TableDefinitionCollection TableDefinitions
+        {
+            get { return this.tableDefinitions; }
+        }
+
+        /// <summary>
+        /// Gets or sets the Wix variable resolver.
+        /// </summary>
+        /// <value>The Wix variable resolver.</value>
+        public WixVariableResolver WixVariableResolver { get; set; }
+
+        /// <summary>
+        /// Adds an extension.
+        /// </summary>
+        /// <param name="extension">The extension to add.</param>
+        public void AddExtensionData(IExtensionData extension)
+        {
+            if (null != extension.TableDefinitions)
+            {
+                foreach (TableDefinition tableDefinition in extension.TableDefinitions)
+                {
+                    if (!this.tableDefinitions.Contains(tableDefinition.Name))
+                    {
+                        this.tableDefinitions.Add(tableDefinition);
+                    }
+                    else
+                    {
+                        throw new WixException(WixErrors.DuplicateExtensionTable(extension.GetType().ToString(), tableDefinition.Name));
+                    }
+                }
+            }
+
+            // keep track of extension data so the libraries can be loaded from these later once all the table definitions
+            // are loaded; this will allow extensions to have cross table definition dependencies
+            this.extensionData.Add(extension);
+        }
+
+        /// <summary>
+        /// Links a collection of sections into an output.
+        /// </summary>
+        /// <param name="inputs">The collection of sections to link together.</param>
+        /// <param name="expectedOutputType">Expected output type, based on output file extension provided to the linker.</param>
+        /// <returns>Output object from the linking.</returns>
+        public Output Link(IEnumerable<Section> inputs, OutputType expectedOutputType)
+        {
+            Output output = null;
+            List<Section> sections = new List<Section>(inputs);
+
+            try
+            {
+                bool containsModuleSubstitution = false;
+                bool containsModuleConfiguration = false;
+
+                this.activeOutput = null;
+
+                List<Row> actionRows = new List<Row>();
+                List<Row> suppressActionRows = new List<Row>();
+
+                TableDefinitionCollection customTableDefinitions = new TableDefinitionCollection();
+                List<Row> customRows = new List<Row>();
+
+                StringCollection generatedShortFileNameIdentifiers = new StringCollection();
+                Hashtable generatedShortFileNames = new Hashtable();
+
+                Hashtable multipleFeatureComponents = new Hashtable();
+
+                Hashtable wixVariables = new Hashtable();
+
+                // verify that modularization types match for foreign key relationships
+                foreach (TableDefinition tableDefinition in this.tableDefinitions)
+                {
+                    foreach (ColumnDefinition columnDefinition in tableDefinition.Columns)
+                    {
+                        if (null != columnDefinition.KeyTable && 0 > columnDefinition.KeyTable.IndexOf(';') && columnDefinition.IsKeyColumnSet)
+                        {
+                            try
+                            {
+                                TableDefinition keyTableDefinition = this.tableDefinitions[columnDefinition.KeyTable];
+
+                                if (0 >= columnDefinition.KeyColumn || keyTableDefinition.Columns.Count < columnDefinition.KeyColumn)
+                                {
+                                    this.OnMessage(WixErrors.InvalidKeyColumn(tableDefinition.Name, columnDefinition.Name, columnDefinition.KeyTable, columnDefinition.KeyColumn));
+                                }
+                                else if (keyTableDefinition.Columns[columnDefinition.KeyColumn - 1].ModularizeType != columnDefinition.ModularizeType && ColumnModularizeType.CompanionFile != columnDefinition.ModularizeType)
+                                {
+                                    this.OnMessage(WixErrors.CollidingModularizationTypes(tableDefinition.Name, columnDefinition.Name, columnDefinition.KeyTable, columnDefinition.KeyColumn, columnDefinition.ModularizeType.ToString(), keyTableDefinition.Columns[columnDefinition.KeyColumn - 1].ModularizeType.ToString()));
+                                }
+                            }
+                            catch (WixMissingTableDefinitionException)
+                            {
+                                // ignore missing table definitions - this error is caught in other places
+                            }
+                        }
+                    }
+                }
+
+                // Add sections from the extensions with data.
+                foreach (IExtensionData data in this.extensionData)
+                {
+                    Library library = data.GetLibrary(this.tableDefinitions);
+
+                    if (null != library)
+                    {
+                        sections.AddRange(library.Sections);
+                    }
+                }
+
+                // First find the entry section and while processing all sections load all the symbols from all of the sections.
+                // sections.FindEntrySectionAndLoadSymbols(false, this, expectedOutputType, out entrySection, out allSymbols);
+                FindEntrySectionAndLoadSymbolsCommand find = new FindEntrySectionAndLoadSymbolsCommand(sections);
+                find.ExpectedOutputType = expectedOutputType;
+
+                find.Execute();
+
+                // Must have found the entry section by now.
+                if (null == find.EntrySection)
+                {
+                    throw new WixException(WixErrors.MissingEntrySection(expectedOutputType.ToString()));
+                }
+
+                IDictionary<string, Symbol> allSymbols = find.Symbols;
+
+                // Add the missing standard action symbols.
+                this.LoadStandardActionSymbols(allSymbols);
+
+                // now that we know where we're starting from, create the output object
+                output = new Output(null);
+                output.EntrySection = find.EntrySection; // Note: this entry section will get added to the Output.Sections collection later
+                if (null != this.localizer && -1 != this.localizer.Codepage)
+                {
+                    output.Codepage = this.localizer.Codepage;
+                }
+                this.activeOutput = output;
+
+                // Resolve the symbol references to find the set of sections we care about for linking.
+                // Of course, we start with the entry section (that's how it got its name after all).
+                ResolveReferencesCommand resolve = new ResolveReferencesCommand(output.EntrySection, allSymbols);
+                resolve.BuildingMergeModule = (OutputType.Module == output.Type);
+
+                resolve.Execute();
+
+                if (Messaging.Instance.EncounteredError)
+                {
+                    return null;
+                }
+
+                // Add the resolved sections to the output then flatten the complex
+                // references that particpate in groups.
+                foreach (Section section in resolve.ResolvedSections)
+                {
+                    output.Sections.Add(section);
+                }
+
+                this.FlattenSectionsComplexReferences(output.Sections);
+
+                if (Messaging.Instance.EncounteredError)
+                {
+                    return null;
+                }
+
+                // The hard part in linking is processing the complex references.
+                HashSet<string> referencedComponents = new HashSet<string>();
+                ConnectToFeatureCollection componentsToFeatures = new ConnectToFeatureCollection();
+                ConnectToFeatureCollection featuresToFeatures = new ConnectToFeatureCollection();
+                ConnectToFeatureCollection modulesToFeatures = new ConnectToFeatureCollection();
+                this.ProcessComplexReferences(output, output.Sections, referencedComponents, componentsToFeatures, featuresToFeatures, modulesToFeatures);
+
+                if (Messaging.Instance.EncounteredError)
+                {
+                    return null;
+                }
+
+                // Display an error message for Components that were not referenced by a Feature.
+                foreach (Symbol symbol in resolve.ReferencedSymbols.Where(s => "Component".Equals(s.Row.TableDefinition.Name, StringComparison.Ordinal)))
+                {
+                    if (!referencedComponents.Contains(symbol.Name))
+                    {
+                        this.OnMessage(WixErrors.OrphanedComponent(symbol.Row.SourceLineNumbers, (string)symbol.Row[0]));
+                    }
+                }
+
+                // Report duplicates that would ultimately end up being primary key collisions.
+                ReportConflictingSymbolsCommand reportDupes = new ReportConflictingSymbolsCommand(find.PossiblyConflictingSymbols, resolve.ResolvedSections);
+                reportDupes.Execute();
+
+                if (Messaging.Instance.EncounteredError)
+                {
+                    return null;
+                }
+
+                // resolve the feature to feature connects
+                this.ResolveFeatureToFeatureConnects(featuresToFeatures, allSymbols);
+
+                // start generating OutputTables and OutputRows for all the sections in the output
+                List<Row> ensureTableRows = new List<Row>();
+                int sectionCount = 0;
+                foreach (Section section in output.Sections)
+                {
+                    sectionCount++;
+                    string sectionId = section.Id;
+                    if (null == sectionId && this.sectionIdOnRows)
+                    {
+                        sectionId = "wix.section." + sectionCount.ToString(CultureInfo.InvariantCulture);
+                    }
+
+                    foreach (Table table in section.Tables)
+                    {
+                        bool copyRows = true; // by default, copy rows.
+
+                        // handle special tables
+                        switch (table.Name)
+                        {
+                            case "AppSearch":
+                                this.activeOutput.EnsureTable(this.tableDefinitions["Signature"]);
+                                break;
+
+                            case "Class":
+                                if (OutputType.Product == output.Type)
+                                {
+                                    this.ResolveFeatures(table.Rows, 2, 11, componentsToFeatures, multipleFeatureComponents);
+                                }
+                                break;
+
+                            case "CustomAction":
+                                if (OutputType.Module == this.activeOutput.Type)
+                                {
+                                    this.activeOutput.EnsureTable(this.tableDefinitions["AdminExecuteSequence"]);
+                                    this.activeOutput.EnsureTable(this.tableDefinitions["AdminUISequence"]);
+                                    this.activeOutput.EnsureTable(this.tableDefinitions["AdvtExecuteSequence"]);
+                                    this.activeOutput.EnsureTable(this.tableDefinitions["InstallExecuteSequence"]);
+                                    this.activeOutput.EnsureTable(this.tableDefinitions["InstallUISequence"]);
+                                }
+                                break;
+
+                            case "Dialog":
+                                this.activeOutput.EnsureTable(this.tableDefinitions["ListBox"]);
+                                break;
+
+                            case "Directory":
+                                foreach (Row row in table.Rows)
+                                {
+                                    if (OutputType.Module == this.activeOutput.Type)
+                                    {
+                                        string directory = row[0].ToString();
+                                        if (WindowsInstallerStandard.IsStandardDirectory(directory))
+                                        {
+                                            // if the directory table contains references to standard windows folders
+                                            // mergemod.dll will add customactions to set the MSM directory to 
+                                            // the same directory as the standard windows folder and will add references to 
+                                            // custom action to all the standard sequence tables.  A problem will occur
+                                            // if the MSI does not have these tables as mergemod.dll does not add these
+                                            // tables to the MSI if absent.  This code adds the tables in case mergemod.dll
+                                            // needs them.
+                                            this.activeOutput.EnsureTable(this.tableDefinitions["CustomAction"]);
+                                            this.activeOutput.EnsureTable(this.tableDefinitions["AdminExecuteSequence"]);
+                                            this.activeOutput.EnsureTable(this.tableDefinitions["AdminUISequence"]);
+                                            this.activeOutput.EnsureTable(this.tableDefinitions["AdvtExecuteSequence"]);
+                                            this.activeOutput.EnsureTable(this.tableDefinitions["InstallExecuteSequence"]);
+                                            this.activeOutput.EnsureTable(this.tableDefinitions["InstallUISequence"]);
+                                        }
+                                        else
+                                        {
+                                            foreach (string standardDirectory in WindowsInstallerStandard.GetStandardDirectories())
+                                            {
+                                                if (directory.StartsWith(standardDirectory, StringComparison.Ordinal))
+                                                {
+                                                    this.OnMessage(WixWarnings.StandardDirectoryConflictInMergeModule(row.SourceLineNumbers, directory, standardDirectory));
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                break;
+
+                            case "Extension":
+                                if (OutputType.Product == output.Type)
+                                {
+                                    this.ResolveFeatures(table.Rows, 1, 4, componentsToFeatures, multipleFeatureComponents);
+                                }
+                                break;
+
+                            case "ModuleSubstitution":
+                                containsModuleSubstitution = true;
+                                break;
+
+                            case "ModuleConfiguration":
+                                containsModuleConfiguration = true;
+                                break;
+
+                            case "MsiAssembly":
+                                if (OutputType.Product == output.Type)
+                                {
+                                    this.ResolveFeatures(table.Rows, 0, 1, componentsToFeatures, multipleFeatureComponents);
+                                }
+                                break;
+
+                            case "ProgId":
+                                // the Extension table is required with a ProgId table
+                                this.activeOutput.EnsureTable(this.tableDefinitions["Extension"]);
+                                break;
+
+                            case "Property":
+                                // Remove property rows with no value. These are properties associated with
+                                // AppSearch but without a default value.
+                                for (int i = 0; i < table.Rows.Count; i++)
+                                {
+                                    if (null == table.Rows[i][1])
+                                    {
+                                        table.Rows.RemoveAt(i);
+                                        i--;
+                                    }
+                                }
+                                break;
+
+                            case "PublishComponent":
+                                if (OutputType.Product == output.Type)
+                                {
+                                    this.ResolveFeatures(table.Rows, 2, 4, componentsToFeatures, multipleFeatureComponents);
+                                }
+                                break;
+
+                            case "Shortcut":
+                                if (OutputType.Product == output.Type)
+                                {
+                                    this.ResolveFeatures(table.Rows, 3, 4, componentsToFeatures, multipleFeatureComponents);
+                                }
+                                break;
+
+                            case "TypeLib":
+                                if (OutputType.Product == output.Type)
+                                {
+                                    this.ResolveFeatures(table.Rows, 2, 6, componentsToFeatures, multipleFeatureComponents);
+                                }
+                                break;
+
+                            case "WixAction":
+                                if (this.sectionIdOnRows)
+                                {
+                                    foreach (Row row in table.Rows)
+                                    {
+                                        row.SectionId = sectionId;
+                                    }
+                                }
+                                actionRows.AddRange(table.Rows);
+                                break;
+
+                            case "WixCustomTable":
+                                this.LinkCustomTable(table, customTableDefinitions);
+                                copyRows = false; // we've created table definitions from these rows, no need to process them any longer
+                                break;
+
+                            case "WixCustomRow":
+                                foreach (Row row in table.Rows)
+                                {
+                                    row.SectionId = (this.sectionIdOnRows ? sectionId : null);
+                                    customRows.Add(row);
+                                }
+                                copyRows = false;
+                                break;
+
+                            case "WixEnsureTable":
+                                ensureTableRows.AddRange(table.Rows);
+                                break;
+
+                            case "WixFile":
+                                foreach (Row row in table.Rows)
+                                {
+                                    // DiskId is not valid when creating a module, so set it to
+                                    // 0 for all files to ensure proper sorting in the binder
+                                    if (OutputType.Module == this.activeOutput.Type)
+                                    {
+                                        row[5] = 0;
+                                    }
+
+                                    // if the short file name was generated, check for collisions
+                                    if (0x1 == (int)row[9])
+                                    {
+                                        generatedShortFileNameIdentifiers.Add((string)row[0]);
+                                    }
+                                }
+                                break;
+
+                            case "WixMerge":
+                                if (OutputType.Product == output.Type)
+                                {
+                                    this.ResolveFeatures(table.Rows, 0, 7, modulesToFeatures, null);
+                                }
+                                break;
+
+                            case "WixSuppressAction":
+                                suppressActionRows.AddRange(table.Rows);
+                                break;
+
+                            case "WixVariable":
+                                // check for colliding values and collect the wix variable rows
+                                foreach (WixVariableRow row in table.Rows)
+                                {
+                                    WixVariableRow collidingRow = (WixVariableRow)wixVariables[row.Id];
+
+                                    if (null == collidingRow || (collidingRow.Overridable && !row.Overridable))
+                                    {
+                                        wixVariables[row.Id] = row;
+                                    }
+                                    else if (!row.Overridable || (collidingRow.Overridable && row.Overridable))
+                                    {
+                                        this.OnMessage(WixErrors.WixVariableCollision(row.SourceLineNumbers, row.Id));
+                                    }
+                                }
+                                copyRows = false;
+                                break;
+                        }
+
+                        if (copyRows)
+                        {
+                            Table outputTable = this.activeOutput.EnsureTable(this.tableDefinitions[table.Name]);
+                            this.CopyTableRowsToOutputTable(table, outputTable, sectionId);
+                        }
+                    }
+                }
+
+                // copy the module to feature connections into the output
+                if (0 < modulesToFeatures.Count)
+                {
+                    Table wixFeatureModulesTable = this.activeOutput.EnsureTable(this.tableDefinitions["WixFeatureModules"]);
+
+                    foreach (ConnectToFeature connectToFeature in modulesToFeatures)
+                    {
+                        foreach (string feature in connectToFeature.ConnectFeatures)
+                        {
+                            Row row = wixFeatureModulesTable.CreateRow(null);
+                            row[0] = feature;
+                            row[1] = connectToFeature.ChildId;
+                        }
+                    }
+                }
+
+                // ensure the creation of tables that need to exist
+                if (0 < ensureTableRows.Count)
+                {
+                    foreach (Row row in ensureTableRows)
+                    {
+                        string tableId = (string)row[0];
+                        TableDefinition tableDef = null;
+
+                        try
+                        {
+                            tableDef = this.tableDefinitions[tableId];
+                        }
+                        catch (WixMissingTableDefinitionException)
+                        {
+                            tableDef = customTableDefinitions[tableId];
+                        }
+
+                        this.activeOutput.EnsureTable(tableDef);
+                    }
+                }
+
+                // copy all the suppress action rows to the output to suppress actions from merge modules
+                if (0 < suppressActionRows.Count)
+                {
+                    Table suppressActionTable = this.activeOutput.EnsureTable(this.tableDefinitions["WixSuppressAction"]);
+                    suppressActionRows.ForEach(r => suppressActionTable.Rows.Add(r));
+                }
+
+                // sequence all the actions
+                this.SequenceActions(actionRows, suppressActionRows);
+
+                // check for missing table and add them or display an error as appropriate
+                switch (this.activeOutput.Type)
+                {
+                    case OutputType.Module:
+                        this.activeOutput.EnsureTable(this.tableDefinitions["Component"]);
+                        this.activeOutput.EnsureTable(this.tableDefinitions["Directory"]);
+                        this.activeOutput.EnsureTable(this.tableDefinitions["FeatureComponents"]);
+                        this.activeOutput.EnsureTable(this.tableDefinitions["File"]);
+                        this.activeOutput.EnsureTable(this.tableDefinitions["ModuleComponents"]);
+                        this.activeOutput.EnsureTable(this.tableDefinitions["ModuleSignature"]);
+                        break;
+                    case OutputType.PatchCreation:
+                        Table imageFamiliesTable = this.activeOutput.Tables["ImageFamilies"];
+                        Table targetImagesTable = this.activeOutput.Tables["TargetImages"];
+                        Table upgradedImagesTable = this.activeOutput.Tables["UpgradedImages"];
+
+                        if (null == imageFamiliesTable || 1 > imageFamiliesTable.Rows.Count)
+                        {
+                            this.OnMessage(WixErrors.ExpectedRowInPatchCreationPackage("ImageFamilies"));
+                        }
+
+                        if (null == targetImagesTable || 1 > targetImagesTable.Rows.Count)
+                        {
+                            this.OnMessage(WixErrors.ExpectedRowInPatchCreationPackage("TargetImages"));
+                        }
+
+                        if (null == upgradedImagesTable || 1 > upgradedImagesTable.Rows.Count)
+                        {
+                            this.OnMessage(WixErrors.ExpectedRowInPatchCreationPackage("UpgradedImages"));
+                        }
+
+                        this.activeOutput.EnsureTable(this.tableDefinitions["Properties"]);
+                        break;
+                    case OutputType.Product:
+                        this.activeOutput.EnsureTable(this.tableDefinitions["File"]);
+                        this.activeOutput.EnsureTable(this.tableDefinitions["Media"]);
+                        break;
+                }
+
+                this.CheckForIllegalTables(this.activeOutput);
+
+                // add the custom row data
+                foreach (Row row in customRows)
+                {
+                    TableDefinition customTableDefinition = (TableDefinition)customTableDefinitions[row[0].ToString()];
+                    Table customTable = this.activeOutput.EnsureTable(customTableDefinition);
+                    Row customRow = customTable.CreateRow(row.SourceLineNumbers);
+
+                    customRow.SectionId = row.SectionId;
+
+                    string[] data = row[1].ToString().Split(Common.CustomRowFieldSeparator);
+
+                    for (int i = 0; i < data.Length; ++i)
+                    {
+                        bool foundColumn = false;
+                        string[] item = data[i].Split(colonCharacter, 2);
+
+                        for (int j = 0; j < customRow.Fields.Length; ++j)
+                        {
+                            if (customRow.Fields[j].Column.Name == item[0])
+                            {
+                                if (0 < item[1].Length)
+                                {
+                                    if (ColumnType.Number == customRow.Fields[j].Column.Type)
+                                    {
+                                        try
+                                        {
+                                            customRow.Fields[j].Data = Convert.ToInt32(item[1], CultureInfo.InvariantCulture);
+                                        }
+                                        catch (FormatException)
+                                        {
+                                            this.OnMessage(WixErrors.IllegalIntegerValue(row.SourceLineNumbers, customTableDefinition.Columns[i].Name, customTableDefinition.Name, item[1]));
+                                        }
+                                        catch (OverflowException)
+                                        {
+                                            this.OnMessage(WixErrors.IllegalIntegerValue(row.SourceLineNumbers, customTableDefinition.Columns[i].Name, customTableDefinition.Name, item[1]));
+                                        }
+                                    }
+                                    else if (ColumnCategory.Identifier == customRow.Fields[j].Column.Category)
+                                    {
+                                        if (Common.IsIdentifier(item[1]) || Common.IsValidBinderVariable(item[1]) || ColumnCategory.Formatted == customRow.Fields[j].Column.Category)
+                                        {
+                                            customRow.Fields[j].Data = item[1];
+                                        }
+                                        else
+                                        {
+                                            this.OnMessage(WixErrors.IllegalIdentifier(row.SourceLineNumbers, "Data", item[1]));
+                                        }
+                                    }
+                                    else
+                                    {
+                                        customRow.Fields[j].Data = item[1];
+                                    }
+                                }
+                                foundColumn = true;
+                                break;
+                            }
+                        }
+
+                        if (!foundColumn)
+                        {
+                            this.OnMessage(WixErrors.UnexpectedCustomTableColumn(row.SourceLineNumbers, item[0]));
+                        }
+                    }
+
+                    for (int i = 0; i < customTableDefinition.Columns.Count; ++i)
+                    {
+                        if (!customTableDefinition.Columns[i].Nullable && (null == customRow.Fields[i].Data || 0 == customRow.Fields[i].Data.ToString().Length))
+                        {
+                            this.OnMessage(WixErrors.NoDataForColumn(row.SourceLineNumbers, customTableDefinition.Columns[i].Name, customTableDefinition.Name));
+                        }
+                    }
+                }
+
+                //correct the section Id in FeatureComponents table
+                if (this.sectionIdOnRows)
+                {
+                    Hashtable componentSectionIds = new Hashtable();
+                    Table componentTable = output.Tables["Component"];
+
+                    if (null != componentTable)
+                    {
+                        foreach (Row componentRow in componentTable.Rows)
+                        {
+                            componentSectionIds.Add(componentRow.Fields[0].Data.ToString(), componentRow.SectionId);
+                        }
+                    }
+
+                    Table featureComponentsTable = output.Tables["FeatureComponents"];
+
+                    if (null != featureComponentsTable)
+                    {
+                        foreach (Row featureComponentsRow in featureComponentsTable.Rows)
+                        {
+                            if (componentSectionIds.Contains(featureComponentsRow.Fields[1].Data.ToString()))
+                            {
+                                featureComponentsRow.SectionId = (string)componentSectionIds[featureComponentsRow.Fields[1].Data.ToString()];
+                            }
+                        }
+                    }
+                }
+
+                // add the ModuleSubstitution table to the ModuleIgnoreTable
+                if (containsModuleSubstitution)
+                {
+                    Table moduleIgnoreTableTable = this.activeOutput.EnsureTable(this.tableDefinitions["ModuleIgnoreTable"]);
+
+                    Row moduleIgnoreTableRow = moduleIgnoreTableTable.CreateRow(null);
+                    moduleIgnoreTableRow[0] = "ModuleSubstitution";
+                }
+
+                // add the ModuleConfiguration table to the ModuleIgnoreTable
+                if (containsModuleConfiguration)
+                {
+                    Table moduleIgnoreTableTable = this.activeOutput.EnsureTable(this.tableDefinitions["ModuleIgnoreTable"]);
+
+                    Row moduleIgnoreTableRow = moduleIgnoreTableTable.CreateRow(null);
+                    moduleIgnoreTableRow[0] = "ModuleConfiguration";
+                }
+
+                // index all the file rows
+                Table fileTable = this.activeOutput.Tables["File"];
+                RowDictionary<FileRow> indexedFileRows = (null == fileTable) ? new RowDictionary<FileRow>() : new RowDictionary<FileRow>(fileTable);
+
+                // flag all the generated short file name collisions
+                foreach (string fileId in generatedShortFileNameIdentifiers)
+                {
+                    FileRow fileRow = indexedFileRows[fileId];
+
+                    string[] names = fileRow.FileName.Split('|');
+                    string shortFileName = names[0];
+
+                    // create lists of conflicting generated short file names
+                    if (!generatedShortFileNames.Contains(shortFileName))
+                    {
+                        generatedShortFileNames.Add(shortFileName, new ArrayList());
+                    }
+                    ((ArrayList)generatedShortFileNames[shortFileName]).Add(fileRow);
+                }
+
+                // check for generated short file name collisions
+                foreach (DictionaryEntry entry in generatedShortFileNames)
+                {
+                    string shortFileName = (string)entry.Key;
+                    ArrayList fileRows = (ArrayList)entry.Value;
+
+                    if (1 < fileRows.Count)
+                    {
+                        // sort the rows by DiskId
+                        fileRows.Sort();
+
+                        this.OnMessage(WixWarnings.GeneratedShortFileNameConflict(((FileRow)fileRows[0]).SourceLineNumbers, shortFileName));
+
+                        for (int i = 1; i < fileRows.Count; i++)
+                        {
+                            FileRow fileRow = (FileRow)fileRows[i];
+
+                            if (null != fileRow.SourceLineNumbers)
+                            {
+                                this.OnMessage(WixWarnings.GeneratedShortFileNameConflict2(fileRow.SourceLineNumbers));
+                            }
+                        }
+                    }
+                }
+
+                // copy the wix variable rows to the output after all overriding has been accounted for.
+                if (0 < wixVariables.Count)
+                {
+                    Table wixVariableTable = output.EnsureTable(this.tableDefinitions["WixVariable"]);
+
+                    foreach (WixVariableRow row in wixVariables.Values)
+                    {
+                        wixVariableTable.Rows.Add(row);
+                    }
+                }
+
+                // Bundles have groups of data that must be flattened in a way different from other types.
+                this.FlattenBundleTables(output);
+
+                if (Messaging.Instance.EncounteredError)
+                {
+                    return null;
+                }
+
+                this.CheckOutputConsistency(output);
+
+                // inspect the output
+                InspectorCore inspectorCore = new InspectorCore();
+                foreach (InspectorExtension inspectorExtension in this.inspectorExtensions)
+                {
+                    inspectorExtension.Core = inspectorCore;
+                    inspectorExtension.InspectOutput(output);
+
+                    // reset
+                    inspectorExtension.Core = null;
+                }
+            }
+            finally
+            {
+                this.activeOutput = null;
+            }
+
+            return Messaging.Instance.EncounteredError ? null : output;
+        }
+
+        /// <summary>
+        /// Links the definition of a custom table.
+        /// </summary>
+        /// <param name="table">The table to link.</param>
+        /// <param name="customTableDefinitions">Receives the linked definition of the custom table.</param>
+        private void LinkCustomTable(Table table, TableDefinitionCollection customTableDefinitions)
+        {
+            foreach (Row row in table.Rows)
+            {
+                bool bootstrapperApplicationData = (null != row[13] && 1 == (int)row[13]);
+
+                if (null == row[4])
+                {
+                    this.OnMessage(WixErrors.ExpectedAttribute(row.SourceLineNumbers, "CustomTable/Column", "PrimaryKey"));
+                }
+
+                string[] columnNames = row[2].ToString().Split('\t');
+                string[] columnTypes = row[3].ToString().Split('\t');
+                string[] primaryKeys = row[4].ToString().Split('\t');
+                string[] minValues = row[5] == null ? null : row[5].ToString().Split('\t');
+                string[] maxValues = row[6] == null ? null : row[6].ToString().Split('\t');
+                string[] keyTables = row[7] == null ? null : row[7].ToString().Split('\t');
+                string[] keyColumns = row[8] == null ? null : row[8].ToString().Split('\t');
+                string[] categories = row[9] == null ? null : row[9].ToString().Split('\t');
+                string[] sets = row[10] == null ? null : row[10].ToString().Split('\t');
+                string[] descriptions = row[11] == null ? null : row[11].ToString().Split('\t');
+                string[] modularizations = row[12] == null ? null : row[12].ToString().Split('\t');
+
+                int currentPrimaryKey = 0;
+
+                List<ColumnDefinition> columns = new List<ColumnDefinition>(columnNames.Length);
+                for (int i = 0; i < columnNames.Length; ++i)
+                {
+                    string name = columnNames[i];
+                    ColumnType type = ColumnType.Unknown;
+
+                    if (columnTypes[i].StartsWith("s", StringComparison.OrdinalIgnoreCase))
+                    {
+                        type = ColumnType.String;
+                    }
+                    else if (columnTypes[i].StartsWith("l", StringComparison.OrdinalIgnoreCase))
+                    {
+                        type = ColumnType.Localized;
+                    }
+                    else if (columnTypes[i].StartsWith("i", StringComparison.OrdinalIgnoreCase))
+                    {
+                        type = ColumnType.Number;
+                    }
+                    else if (columnTypes[i].StartsWith("v", StringComparison.OrdinalIgnoreCase))
+                    {
+                        type = ColumnType.Object;
+                    }
+                    else
+                    {
+                        throw new WixException(WixErrors.UnknownCustomTableColumnType(row.SourceLineNumbers, columnTypes[i]));
+                    }
+
+                    bool nullable = columnTypes[i].Substring(0, 1) == columnTypes[i].Substring(0, 1).ToUpper(CultureInfo.InvariantCulture);
+                    int length = Convert.ToInt32(columnTypes[i].Substring(1), CultureInfo.InvariantCulture);
+
+                    bool primaryKey = false;
+                    if (currentPrimaryKey < primaryKeys.Length && primaryKeys[currentPrimaryKey] == columnNames[i])
+                    {
+                        primaryKey = true;
+                        currentPrimaryKey++;
+                    }
+
+                    bool minValSet = null != minValues && null != minValues[i] && 0 < minValues[i].Length;
+                    int minValue = 0;
+                    if (minValSet)
+                    {
+                        minValue = Convert.ToInt32(minValues[i], CultureInfo.InvariantCulture);
+                    }
+
+                    bool maxValSet = null != maxValues && null != maxValues[i] && 0 < maxValues[i].Length;
+                    int maxValue = 0;
+                    if (maxValSet)
+                    {
+                        maxValue = Convert.ToInt32(maxValues[i], CultureInfo.InvariantCulture);
+                    }
+
+                    bool keyColumnSet = null != keyColumns && null != keyColumns[i] && 0 < keyColumns[i].Length;
+                    int keyColumn = 0;
+                    if (keyColumnSet)
+                    {
+                        keyColumn = Convert.ToInt32(keyColumns[i], CultureInfo.InvariantCulture);
+                    }
+
+                    ColumnCategory category = ColumnCategory.Unknown;
+                    if (null != categories && null != categories[i] && 0 < categories[i].Length)
+                    {
+                        switch (categories[i])
+                        {
+                            case "Text":
+                                category = ColumnCategory.Text;
+                                break;
+                            case "UpperCase":
+                                category = ColumnCategory.UpperCase;
+                                break;
+                            case "LowerCase":
+                                category = ColumnCategory.LowerCase;
+                                break;
+                            case "Integer":
+                                category = ColumnCategory.Integer;
+                                break;
+                            case "DoubleInteger":
+                                category = ColumnCategory.DoubleInteger;
+                                break;
+                            case "TimeDate":
+                                category = ColumnCategory.TimeDate;
+                                break;
+                            case "Identifier":
+                                category = ColumnCategory.Identifier;
+                                break;
+                            case "Property":
+                                category = ColumnCategory.Property;
+                                break;
+                            case "Filename":
+                                category = ColumnCategory.Filename;
+                                break;
+                            case "WildCardFilename":
+                                category = ColumnCategory.WildCardFilename;
+                                break;
+                            case "Path":
+                                category = ColumnCategory.Path;
+                                break;
+                            case "Paths":
+                                category = ColumnCategory.Paths;
+                                break;
+                            case "AnyPath":
+                                category = ColumnCategory.AnyPath;
+                                break;
+                            case "DefaultDir":
+                                category = ColumnCategory.DefaultDir;
+                                break;
+                            case "RegPath":
+                                category = ColumnCategory.RegPath;
+                                break;
+                            case "Formatted":
+                                category = ColumnCategory.Formatted;
+                                break;
+                            case "FormattedSddl":
+                                category = ColumnCategory.FormattedSDDLText;
+                                break;
+                            case "Template":
+                                category = ColumnCategory.Template;
+                                break;
+                            case "Condition":
+                                category = ColumnCategory.Condition;
+                                break;
+                            case "Guid":
+                                category = ColumnCategory.Guid;
+                                break;
+                            case "Version":
+                                category = ColumnCategory.Version;
+                                break;
+                            case "Language":
+                                category = ColumnCategory.Language;
+                                break;
+                            case "Binary":
+                                category = ColumnCategory.Binary;
+                                break;
+                            case "CustomSource":
+                                category = ColumnCategory.CustomSource;
+                                break;
+                            case "Cabinet":
+                                category = ColumnCategory.Cabinet;
+                                break;
+                            case "Shortcut":
+                                category = ColumnCategory.Shortcut;
+                                break;
+                            default:
+                                break;
+                        }
+                    }
+
+                    string keyTable = keyTables != null ? keyTables[i] : null;
+                    string setValue = sets != null ? sets[i] : null;
+                    string description = descriptions != null ? descriptions[i] : null;
+                    string modString = modularizations != null ? modularizations[i] : null;
+                    ColumnModularizeType modularization = ColumnModularizeType.None;
+                    if (modString != null)
+                    {
+                        switch (modString)
+                        {
+                            case "None":
+                                modularization = ColumnModularizeType.None;
+                                break;
+                            case "Column":
+                                modularization = ColumnModularizeType.Column;
+                                break;
+                            case "Property":
+                                modularization = ColumnModularizeType.Property;
+                                break;
+                            case "Condition":
+                                modularization = ColumnModularizeType.Condition;
+                                break;
+                            case "CompanionFile":
+                                modularization = ColumnModularizeType.CompanionFile;
+                                break;
+                            case "SemicolonDelimited":
+                                modularization = ColumnModularizeType.SemicolonDelimited;
+                                break;
+                        }
+                    }
+
+                    ColumnDefinition columnDefinition = new ColumnDefinition(name, type, length, primaryKey, nullable, modularization, ColumnType.Localized == type, minValSet, minValue, maxValSet, maxValue, keyTable, keyColumnSet, keyColumn, category, setValue, description, true, true);
+                    columns.Add(columnDefinition);
+                }
+
+                TableDefinition customTable = new TableDefinition((string)row[0], columns, false, bootstrapperApplicationData, bootstrapperApplicationData);
+                customTableDefinitions.Add(customTable);
+            }
+        }
+
+        /// <summary>
+        /// Checks for any tables in the output which are not allowed in the output type.
+        /// </summary>
+        /// <param name="output">The output to check.</param>
+        private void CheckForIllegalTables(Output output)
+        {
+            foreach (Table table in output.Tables)
+            {
+                switch (output.Type)
+                {
+                    case OutputType.Module:
+                        if ("BBControl" == table.Name ||
+                            "Billboard" == table.Name ||
+                            "CCPSearch" == table.Name ||
+                            "Feature" == table.Name ||
+                            "LaunchCondition" == table.Name ||
+                            "Media" == table.Name ||
+                            "Patch" == table.Name ||
+                            "Upgrade" == table.Name ||
+                            "WixMerge" == table.Name)
+                        {
+                            foreach (Row row in table.Rows)
+                            {
+                                this.OnMessage(WixErrors.UnexpectedTableInMergeModule(row.SourceLineNumbers, table.Name));
+                            }
+                        }
+                        else if ("Error" == table.Name)
+                        {
+                            foreach (Row row in table.Rows)
+                            {
+                                this.OnMessage(WixWarnings.DangerousTableInMergeModule(row.SourceLineNumbers, table.Name));
+                            }
+                        }
+                        break;
+                    case OutputType.PatchCreation:
+                        if (!table.Definition.Unreal &&
+                            "_SummaryInformation" != table.Name &&
+                            "ExternalFiles" != table.Name &&
+                            "FamilyFileRanges" != table.Name &&
+                            "ImageFamilies" != table.Name &&
+                            "PatchMetadata" != table.Name &&
+                            "PatchSequence" != table.Name &&
+                            "Properties" != table.Name &&
+                            "TargetFiles_OptionalData" != table.Name &&
+                            "TargetImages" != table.Name &&
+                            "UpgradedFiles_OptionalData" != table.Name &&
+                            "UpgradedFilesToIgnore" != table.Name &&
+                            "UpgradedImages" != table.Name)
+                        {
+                            foreach (Row row in table.Rows)
+                            {
+                                this.OnMessage(WixErrors.UnexpectedTableInPatchCreationPackage(row.SourceLineNumbers, table.Name));
+                            }
+                        }
+                        break;
+                    case OutputType.Patch:
+                        if (!table.Definition.Unreal &&
+                            "_SummaryInformation" != table.Name &&
+                            "Media" != table.Name &&
+                            "MsiPatchMetadata" != table.Name &&
+                            "MsiPatchSequence" != table.Name)
+                        {
+                            foreach (Row row in table.Rows)
+                            {
+                                this.OnMessage(WixErrors.UnexpectedTableInPatch(row.SourceLineNumbers, table.Name));
+                            }
+                        }
+                        break;
+                    case OutputType.Product:
+                        if ("ModuleAdminExecuteSequence" == table.Name ||
+                            "ModuleAdminUISequence" == table.Name ||
+                            "ModuleAdvtExecuteSequence" == table.Name ||
+                            "ModuleAdvtUISequence" == table.Name ||
+                            "ModuleComponents" == table.Name ||
+                            "ModuleConfiguration" == table.Name ||
+                            "ModuleDependency" == table.Name ||
+                            "ModuleExclusion" == table.Name ||
+                            "ModuleIgnoreTable" == table.Name ||
+                            "ModuleInstallExecuteSequence" == table.Name ||
+                            "ModuleInstallUISequence" == table.Name ||
+                            "ModuleSignature" == table.Name ||
+                            "ModuleSubstitution" == table.Name)
+                        {
+                            foreach (Row row in table.Rows)
+                            {
+                                this.OnMessage(WixWarnings.UnexpectedTableInProduct(row.SourceLineNumbers, table.Name));
+                            }
+                        }
+                        break;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Performs various consistency checks on the output.
+        /// </summary>
+        /// <param name="output">Output containing instance transform definitions.</param>
+        private void CheckOutputConsistency(Output output)
+        {
+            // Get the output's minimum installer version
+            int outputInstallerVersion = int.MinValue;
+            Table summaryInformationTable = output.Tables["_SummaryInformation"];
+            if (null != summaryInformationTable)
+            {
+                foreach (Row row in summaryInformationTable.Rows)
+                {
+                    if (14 == (int)row[0])
+                    {
+                        outputInstallerVersion = Convert.ToInt32(row[1], CultureInfo.InvariantCulture);
+                        break;
+                    }
+                }
+            }
+
+            // ensure the Error table exists if output is marked for MSI 1.0 or below (see ICE40)
+            if (100 >= outputInstallerVersion && OutputType.Product == output.Type)
+            {
+                output.EnsureTable(this.tableDefinitions["Error"]);
+            }
+
+            // check for the presence of tables/rows/columns that require MSI 1.1 or later
+            if (110 > outputInstallerVersion)
+            {
+                Table isolatedComponentTable = output.Tables["IsolatedComponent"];
+                if (null != isolatedComponentTable)
+                {
+                    foreach (Row row in isolatedComponentTable.Rows)
+                    {
+                        this.OnMessage(WixWarnings.TableIncompatibleWithInstallerVersion(row.SourceLineNumbers, "IsolatedComponent", outputInstallerVersion));
+                    }
+                }
+            }
+
+            // check for the presence of tables/rows/columns that require MSI 4.0 or later
+            if (400 > outputInstallerVersion)
+            {
+                Table shortcutTable = output.Tables["Shortcut"];
+                if (null != shortcutTable)
+                {
+                    foreach (Row row in shortcutTable.Rows)
+                    {
+                        if (null != row[12] || null != row[13] || null != row[14] || null != row[15])
+                        {
+                            this.OnMessage(WixWarnings.ColumnsIncompatibleWithInstallerVersion(row.SourceLineNumbers, "Shortcut", outputInstallerVersion));
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Sends a message to the message delegate if there is one.
+        /// </summary>
+        /// <param name="mea">Message event arguments.</param>
+        public void OnMessage(MessageEventArgs e)
+        {
+            Messaging.Instance.OnMessage(e);
+        }
+
+        /// <summary>
+        /// Load the standard action symbols.
+        /// </summary>
+        /// <param name="allSymbols">Collection of symbols.</param>
+        private void LoadStandardActionSymbols(IDictionary<string, Symbol> allSymbols)
+        {
+            foreach (WixActionRow actionRow in this.standardActions)
+            {
+                Symbol actionSymbol = new Symbol(actionRow);
+
+                // If the action's symbol has not already been defined (i.e. overriden by the user), add it now.
+                if (!allSymbols.ContainsKey(actionSymbol.Name))
+                {
+                    allSymbols.Add(actionSymbol.Name, actionSymbol);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Process the complex references.
+        /// </summary>
+        /// <param name="output">Active output to add sections to.</param>
+        /// <param name="sections">Sections that are referenced during the link process.</param>
+        /// <param name="referencedComponents">Collection of all components referenced by complex reference.</param>
+        /// <param name="componentsToFeatures">Component to feature complex references.</param>
+        /// <param name="featuresToFeatures">Feature to feature complex references.</param>
+        /// <param name="modulesToFeatures">Module to feature complex references.</param>
+        private void ProcessComplexReferences(Output output, IEnumerable<Section> sections, ISet<string> referencedComponents, ConnectToFeatureCollection componentsToFeatures, ConnectToFeatureCollection featuresToFeatures, ConnectToFeatureCollection modulesToFeatures)
+        {
+            Hashtable componentsToModules = new Hashtable();
+
+            foreach (Section section in sections)
+            {
+                Table wixComplexReferenceTable = section.Tables["WixComplexReference"];
+
+                if (null != wixComplexReferenceTable)
+                {
+                    foreach (WixComplexReferenceRow wixComplexReferenceRow in wixComplexReferenceTable.Rows)
+                    {
+                        ConnectToFeature connection;
+                        switch (wixComplexReferenceRow.ParentType)
+                        {
+                            case ComplexReferenceParentType.Feature:
+                                switch (wixComplexReferenceRow.ChildType)
+                                {
+                                    case ComplexReferenceChildType.Component:
+                                        connection = componentsToFeatures[wixComplexReferenceRow.ChildId];
+                                        if (null == connection)
+                                        {
+                                            componentsToFeatures.Add(new ConnectToFeature(section, wixComplexReferenceRow.ChildId, wixComplexReferenceRow.ParentId, wixComplexReferenceRow.IsPrimary));
+                                        }
+                                        else if (wixComplexReferenceRow.IsPrimary)
+                                        {
+                                            if (connection.IsExplicitPrimaryFeature)
+                                            {
+                                                this.OnMessage(WixErrors.MultiplePrimaryReferences(section.SourceLineNumbers, wixComplexReferenceRow.ChildType.ToString(), wixComplexReferenceRow.ChildId, wixComplexReferenceRow.ParentType.ToString(), wixComplexReferenceRow.ParentId, (null != connection.PrimaryFeature ? "Feature" : "Product"), (null != connection.PrimaryFeature ? connection.PrimaryFeature : this.activeOutput.EntrySection.Id)));
+                                                continue;
+                                            }
+                                            else
+                                            {
+                                                connection.ConnectFeatures.Add(connection.PrimaryFeature); // move the guessed primary feature to the list of connects
+                                                connection.PrimaryFeature = wixComplexReferenceRow.ParentId; // set the new primary feature
+                                                connection.IsExplicitPrimaryFeature = true; // and make sure we remember that we set it so we can fail if we try to set it again
+                                            }
+                                        }
+                                        else
+                                        {
+                                            connection.ConnectFeatures.Add(wixComplexReferenceRow.ParentId);
+                                        }
+
+                                        // add a row to the FeatureComponents table
+                                        Table featureComponentsTable = output.EnsureTable(this.tableDefinitions["FeatureComponents"]);
+                                        Row row = featureComponentsTable.CreateRow(null);
+                                        if (this.sectionIdOnRows)
+                                        {
+                                            row.SectionId = section.Id;
+                                        }
+                                        row[0] = wixComplexReferenceRow.ParentId;
+                                        row[1] = wixComplexReferenceRow.ChildId;
+
+                                        // index the component for finding orphaned records
+                                        string symbolName = String.Concat("Component:", wixComplexReferenceRow.ChildId);
+                                        referencedComponents.Add(symbolName);
+
+                                        break;
+
+                                    case ComplexReferenceChildType.Feature:
+                                        connection = featuresToFeatures[wixComplexReferenceRow.ChildId];
+                                        if (null != connection)
+                                        {
+                                            this.OnMessage(WixErrors.MultiplePrimaryReferences(section.SourceLineNumbers, wixComplexReferenceRow.ChildType.ToString(), wixComplexReferenceRow.ChildId, wixComplexReferenceRow.ParentType.ToString(), wixComplexReferenceRow.ParentId, (null != connection.PrimaryFeature ? "Feature" : "Product"), (null != connection.PrimaryFeature ? connection.PrimaryFeature : this.activeOutput.EntrySection.Id)));
+                                            continue;
+                                        }
+
+                                        featuresToFeatures.Add(new ConnectToFeature(section, wixComplexReferenceRow.ChildId, wixComplexReferenceRow.ParentId, wixComplexReferenceRow.IsPrimary));
+                                        break;
+
+                                    case ComplexReferenceChildType.Module:
+                                        connection = modulesToFeatures[wixComplexReferenceRow.ChildId];
+                                        if (null == connection)
+                                        {
+                                            modulesToFeatures.Add(new ConnectToFeature(section, wixComplexReferenceRow.ChildId, wixComplexReferenceRow.ParentId, wixComplexReferenceRow.IsPrimary));
+                                        }
+                                        else if (wixComplexReferenceRow.IsPrimary)
+                                        {
+                                            if (connection.IsExplicitPrimaryFeature)
+                                            {
+                                                this.OnMessage(WixErrors.MultiplePrimaryReferences(section.SourceLineNumbers, wixComplexReferenceRow.ChildType.ToString(), wixComplexReferenceRow.ChildId, wixComplexReferenceRow.ParentType.ToString(), wixComplexReferenceRow.ParentId, (null != connection.PrimaryFeature ? "Feature" : "Product"), (null != connection.PrimaryFeature ? connection.PrimaryFeature : this.activeOutput.EntrySection.Id)));
+                                                continue;
+                                            }
+                                            else
+                                            {
+                                                connection.ConnectFeatures.Add(connection.PrimaryFeature); // move the guessed primary feature to the list of connects
+                                                connection.PrimaryFeature = wixComplexReferenceRow.ParentId; // set the new primary feature
+                                                connection.IsExplicitPrimaryFeature = true; // and make sure we remember that we set it so we can fail if we try to set it again
+                                            }
+                                        }
+                                        else
+                                        {
+                                            connection.ConnectFeatures.Add(wixComplexReferenceRow.ParentId);
+                                        }
+                                        break;
+
+                                    default:
+                                        throw new InvalidOperationException(String.Format(CultureInfo.CurrentUICulture, WixStrings.EXP_UnexpectedComplexReferenceChildType, Enum.GetName(typeof(ComplexReferenceChildType), wixComplexReferenceRow.ChildType)));
+                                }
+                                break;
+
+                            case ComplexReferenceParentType.Module:
+                                switch (wixComplexReferenceRow.ChildType)
+                                {
+                                    case ComplexReferenceChildType.Component:
+                                        if (componentsToModules.ContainsKey(wixComplexReferenceRow.ChildId))
+                                        {
+                                            this.OnMessage(WixErrors.ComponentReferencedTwice(section.SourceLineNumbers, wixComplexReferenceRow.ChildId));
+                                            continue;
+                                        }
+                                        else
+                                        {
+                                            componentsToModules.Add(wixComplexReferenceRow.ChildId, wixComplexReferenceRow); // should always be new
+
+                                            // add a row to the ModuleComponents table
+                                            Table moduleComponentsTable = output.EnsureTable(this.tableDefinitions["ModuleComponents"]);
+                                            Row row = moduleComponentsTable.CreateRow(null);
+                                            if (this.sectionIdOnRows)
+                                            {
+                                                row.SectionId = section.Id;
+                                            }
+                                            row[0] = wixComplexReferenceRow.ChildId;
+                                            row[1] = wixComplexReferenceRow.ParentId;
+                                            row[2] = wixComplexReferenceRow.ParentLanguage;
+                                        }
+
+                                        // index the component for finding orphaned records
+                                        string componentSymbolName = String.Concat("Component:", wixComplexReferenceRow.ChildId);
+                                        referencedComponents.Add(componentSymbolName);
+
+                                        break;
+
+                                    default:
+                                        throw new InvalidOperationException(String.Format(CultureInfo.CurrentUICulture, WixStrings.EXP_UnexpectedComplexReferenceChildType, Enum.GetName(typeof(ComplexReferenceChildType), wixComplexReferenceRow.ChildType)));
+                                }
+                                break;
+
+                            case ComplexReferenceParentType.Patch:
+                                switch (wixComplexReferenceRow.ChildType)
+                                {
+                                    case ComplexReferenceChildType.PatchFamily:
+                                    case ComplexReferenceChildType.PatchFamilyGroup:
+                                        break;
+
+                                    default:
+                                        throw new InvalidOperationException(String.Format(CultureInfo.CurrentUICulture, WixStrings.EXP_UnexpectedComplexReferenceChildType, Enum.GetName(typeof(ComplexReferenceChildType), wixComplexReferenceRow.ChildType)));
+                                }
+                                break;
+
+                            case ComplexReferenceParentType.Product:
+                                switch (wixComplexReferenceRow.ChildType)
+                                {
+                                    case ComplexReferenceChildType.Feature:
+                                        connection = featuresToFeatures[wixComplexReferenceRow.ChildId];
+                                        if (null != connection)
+                                        {
+                                            this.OnMessage(WixErrors.MultiplePrimaryReferences(section.SourceLineNumbers, wixComplexReferenceRow.ChildType.ToString(), wixComplexReferenceRow.ChildId, wixComplexReferenceRow.ParentType.ToString(), wixComplexReferenceRow.ParentId, (null != connection.PrimaryFeature ? "Feature" : "Product"), (null != connection.PrimaryFeature ? connection.PrimaryFeature : this.activeOutput.EntrySection.Id)));
+                                            continue;
+                                        }
+
+                                        featuresToFeatures.Add(new ConnectToFeature(section, wixComplexReferenceRow.ChildId, null, wixComplexReferenceRow.IsPrimary));
+                                        break;
+
+                                    default:
+                                        throw new InvalidOperationException(String.Format(CultureInfo.CurrentUICulture, WixStrings.EXP_UnexpectedComplexReferenceChildType, Enum.GetName(typeof(ComplexReferenceChildType), wixComplexReferenceRow.ChildType)));
+                                }
+                                break;
+
+                            default:
+                                // Note: Groups have been processed before getting here so they are not handled by any case above.
+                                throw new InvalidOperationException(String.Format(CultureInfo.CurrentUICulture, WixStrings.EXP_UnexpectedComplexReferenceChildType, Enum.GetName(typeof(ComplexReferenceParentType), wixComplexReferenceRow.ParentType)));
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Flattens all complex references in all sections in the collection.
+        /// </summary>
+        /// <param name="sections">Sections that are referenced during the link process.</param>
+        private void FlattenSectionsComplexReferences(IEnumerable<Section> sections)
+        {
+            Hashtable parentGroups = new Hashtable();
+            Hashtable parentGroupsSections = new Hashtable();
+            Hashtable parentGroupsNeedingProcessing = new Hashtable();
+
+            // DisplaySectionComplexReferences("--- section's complex references before flattening ---", sections);
+
+            // Step 1:  Gather all of the complex references that are going participate
+            // in the flatting process.  This means complex references that have "grouping
+            //  parents" of Features, Modules, and, of course, Groups.  These references
+            // that participate in a "grouping parent" will be removed from their section
+            // now and after processing added back in Step 3 below.
+            foreach (Section section in sections)
+            {
+                Table wixComplexReferenceTable = section.Tables["WixComplexReference"];
+
+                if (null != wixComplexReferenceTable)
+                {
+                    // Count down because we'll sometimes remove items from the list.
+                    for (int i = wixComplexReferenceTable.Rows.Count - 1; i >= 0; --i)
+                    {
+                        WixComplexReferenceRow wixComplexReferenceRow = (WixComplexReferenceRow)wixComplexReferenceTable.Rows[i];
+
+                        // Only process the "grouping parents" such as FeatureGroup, ComponentGroup, Feature,
+                        // and Module.  Non-grouping complex references are simple and
+                        // resolved during normal complex reference resolutions.
+                        if (ComplexReferenceParentType.FeatureGroup == wixComplexReferenceRow.ParentType ||
+                            ComplexReferenceParentType.ComponentGroup == wixComplexReferenceRow.ParentType ||
+                            ComplexReferenceParentType.Feature == wixComplexReferenceRow.ParentType ||
+                            ComplexReferenceParentType.Module == wixComplexReferenceRow.ParentType ||
+                            ComplexReferenceParentType.PatchFamilyGroup == wixComplexReferenceRow.ParentType ||
+                            ComplexReferenceParentType.Product == wixComplexReferenceRow.ParentType)
+                        {
+                            string parentTypeAndId = CombineTypeAndId(wixComplexReferenceRow.ParentType, wixComplexReferenceRow.ParentId);
+
+                            // Group all complex references with a common parent
+                            // together so we can find them quickly while processing in
+                            // Step 2.
+                            ArrayList childrenComplexRefs = parentGroups[parentTypeAndId] as ArrayList;
+                            if (null == childrenComplexRefs)
+                            {
+                                childrenComplexRefs = new ArrayList();
+                                parentGroups.Add(parentTypeAndId, childrenComplexRefs);
+                            }
+
+                            childrenComplexRefs.Add(wixComplexReferenceRow);
+                            wixComplexReferenceTable.Rows.RemoveAt(i);
+
+                            // Remember the mapping from set of complex references with a common
+                            // parent to their section.  We'll need this to add them back to the
+                            // correct section in Step 3.
+                            Section parentSection = parentGroupsSections[parentTypeAndId] as Section;
+                            if (null == parentSection)
+                            {
+                                parentGroupsSections.Add(parentTypeAndId, section);
+                            }
+                            // Debug.Assert(section == (Section)parentGroupsSections[parentTypeAndId]);
+
+                            // If the child of the complex reference is another group, then in Step 2
+                            // we're going to have to process this complex reference again to copy 
+                            // the child group's references into the parent group.
+                            if ((ComplexReferenceChildType.ComponentGroup == wixComplexReferenceRow.ChildType) ||
+                                (ComplexReferenceChildType.FeatureGroup == wixComplexReferenceRow.ChildType) ||
+                                (ComplexReferenceChildType.PatchFamilyGroup == wixComplexReferenceRow.ChildType))
+                            {
+                                if (!parentGroupsNeedingProcessing.ContainsKey(parentTypeAndId))
+                                {
+                                    parentGroupsNeedingProcessing.Add(parentTypeAndId, section);
+                                }
+                                // Debug.Assert(section == (Section)parentGroupsNeedingProcessing[parentTypeAndId]);
+                            }
+                        }
+                    }
+                }
+            }
+            Debug.Assert(parentGroups.Count == parentGroupsSections.Count);
+            Debug.Assert(parentGroupsNeedingProcessing.Count <= parentGroups.Count);
+
+            // DisplaySectionComplexReferences("\r\n\r\n--- section's complex references middle of flattening ---", sections);
+
+            // Step 2:  Loop through the parent groups that have nested groups removing
+            // them from the hash table as they are processed.  At the end of this the
+            // complex references should all be flattened.
+            string[] keys = new string[parentGroupsNeedingProcessing.Keys.Count];
+            parentGroupsNeedingProcessing.Keys.CopyTo(keys, 0);
+
+            foreach (string key in keys)
+            {
+                if (parentGroupsNeedingProcessing.Contains(key))
+                {
+                    Stack loopDetector = new Stack();
+                    this.FlattenGroup(key, loopDetector, parentGroups, parentGroupsNeedingProcessing);
+                }
+                else
+                {
+                    // the group must have allready been procesed and removed from the hash table
+                }
+            }
+            Debug.Assert(0 == parentGroupsNeedingProcessing.Count);
+
+            // Step 3:  Finally, ensure that all of the groups that were removed
+            // in Step 1 and flattened in Step 2 are added to their appropriate
+            // section.  This is where we will toss out the final no-longer-needed
+            // groups.
+            foreach (string parentGroup in parentGroups.Keys)
+            {
+                Section section = (Section)parentGroupsSections[parentGroup];
+                Table wixComplexReferenceTable = section.Tables["WixComplexReference"];
+
+                foreach (WixComplexReferenceRow wixComplexReferenceRow in (ArrayList)parentGroups[parentGroup])
+                {
+                    if ((ComplexReferenceParentType.FeatureGroup != wixComplexReferenceRow.ParentType) &&
+                        (ComplexReferenceParentType.ComponentGroup != wixComplexReferenceRow.ParentType) &&
+                        (ComplexReferenceParentType.PatchFamilyGroup != wixComplexReferenceRow.ParentType))
+                    {
+                        wixComplexReferenceTable.Rows.Add(wixComplexReferenceRow);
+                    }
+                }
+            }
+
+            // DisplaySectionComplexReferences("\r\n\r\n--- section's complex references after flattening ---", sections);
+        }
+
+        private string CombineTypeAndId(ComplexReferenceParentType type, string id)
+        {
+            return String.Concat(type.ToString(), ":", id);
+        }
+
+        private string CombineTypeAndId(ComplexReferenceChildType type, string id)
+        {
+            return String.Concat(type.ToString(), ":", id);
+        }
+
+        /// <summary>
+        /// Recursively processes the group.
+        /// </summary>
+        /// <param name="parentTypeAndId">String combination type and id of group to process next.</param>
+        /// <param name="loopDetector">Stack of groups processed thus far.  Used to detect loops.</param>
+        /// <param name="parentGroups">Hash table of complex references grouped by parent id.</param>
+        /// <param name="parentGroupsNeedingProcessing">Hash table of parent groups that still have nested groups that need to be flattened.</param>
+        private void FlattenGroup(string parentTypeAndId, Stack loopDetector, Hashtable parentGroups, Hashtable parentGroupsNeedingProcessing)
+        {
+            Debug.Assert(parentGroupsNeedingProcessing.Contains(parentTypeAndId));
+            loopDetector.Push(parentTypeAndId); // push this complex reference parent identfier into the stack for loop verifying
+
+            ArrayList allNewChildComplexReferences = new ArrayList();
+            ArrayList referencesToParent = (ArrayList)parentGroups[parentTypeAndId];
+            foreach (WixComplexReferenceRow wixComplexReferenceRow in referencesToParent)
+            {
+                Debug.Assert(ComplexReferenceParentType.ComponentGroup == wixComplexReferenceRow.ParentType || ComplexReferenceParentType.FeatureGroup == wixComplexReferenceRow.ParentType || ComplexReferenceParentType.Feature == wixComplexReferenceRow.ParentType || ComplexReferenceParentType.Module == wixComplexReferenceRow.ParentType || ComplexReferenceParentType.Product == wixComplexReferenceRow.ParentType || ComplexReferenceParentType.PatchFamilyGroup == wixComplexReferenceRow.ParentType || ComplexReferenceParentType.Patch == wixComplexReferenceRow.ParentType);
+                Debug.Assert(parentTypeAndId == CombineTypeAndId(wixComplexReferenceRow.ParentType, wixComplexReferenceRow.ParentId));
+
+                // We are only interested processing when the child is a group.
+                if ((ComplexReferenceChildType.ComponentGroup == wixComplexReferenceRow.ChildType) ||
+                    (ComplexReferenceChildType.FeatureGroup == wixComplexReferenceRow.ChildType) ||
+                    (ComplexReferenceChildType.PatchFamilyGroup == wixComplexReferenceRow.ChildType))
+                {
+                    string childTypeAndId = CombineTypeAndId(wixComplexReferenceRow.ChildType, wixComplexReferenceRow.ChildId);
+                    if (loopDetector.Contains(childTypeAndId))
+                    {
+                        // Create a comma delimited list of the references that participate in the 
+                        // loop for the error message.  Start at the bottom of the stack and work the
+                        // way up to present the loop as a directed graph.
+                        object[] stack = loopDetector.ToArray();
+                        StringBuilder loop = new StringBuilder();
+                        for (int i = stack.Length - 1; i >= 0; --i)
+                        {
+                            loop.Append((string)stack[i]);
+                            if (0 < i)
+                            {
+                                loop.Append(" -> ");
+                            }
+                        }
+
+                        this.OnMessage(WixErrors.ReferenceLoopDetected(wixComplexReferenceRow.Table.Section == null ? null : wixComplexReferenceRow.Table.Section.SourceLineNumbers, loop.ToString()));
+
+                        // Cleanup the parentGroupsNeedingProcessing and the loopDetector just like the 
+                        // exit of this method does at the end because we are exiting early.
+                        loopDetector.Pop();
+                        parentGroupsNeedingProcessing.Remove(parentTypeAndId);
+                        return; // bail
+                    }
+
+                    // Check to see if the child group still needs to be processed.  If so,
+                    // go do that so that we'll get all of that children's (and children's 
+                    // children) complex references correctly merged into our parent group.
+                    if (parentGroupsNeedingProcessing.ContainsKey(childTypeAndId))
+                    {
+                        this.FlattenGroup(childTypeAndId, loopDetector, parentGroups, parentGroupsNeedingProcessing);
+                    }
+
+                    // If the child is a parent to anything (i.e. the parent has grandchildren)
+                    // clone each of the children's complex references, repoint them to the parent
+                    // complex reference (because we're moving references up the tree), and finally
+                    // add the cloned child's complex reference to the list of complex references 
+                    // that we'll eventually add to the parent group.
+                    ArrayList referencesToChild = (ArrayList)parentGroups[childTypeAndId];
+                    if (null != referencesToChild)
+                    {
+                        foreach (WixComplexReferenceRow crefChild in referencesToChild)
+                        {
+                            // Only merge up the non-group items since groups are purged
+                            // after this part of the processing anyway (cloning them would
+                            // be a complete waste of time).
+                            if ((ComplexReferenceChildType.FeatureGroup != crefChild.ChildType) ||
+                                (ComplexReferenceChildType.ComponentGroup != crefChild.ChildType) ||
+                                (ComplexReferenceChildType.PatchFamilyGroup != crefChild.ChildType))
+                            {
+                                WixComplexReferenceRow crefChildClone = crefChild.Clone();
+                                Debug.Assert(crefChildClone.ParentId == wixComplexReferenceRow.ChildId);
+
+                                crefChildClone.Reparent(wixComplexReferenceRow);
+                                allNewChildComplexReferences.Add(crefChildClone);
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Add the children group's complex references to the parent
+            // group.  Clean out any left over groups and quietly remove any
+            // duplicate complex references that occurred during the merge.
+            referencesToParent.AddRange(allNewChildComplexReferences);
+            referencesToParent.Sort();
+            for (int i = referencesToParent.Count - 1; i >= 0; --i)
+            {
+                WixComplexReferenceRow wixComplexReferenceRow = (WixComplexReferenceRow)referencesToParent[i];
+                if ((ComplexReferenceChildType.FeatureGroup == wixComplexReferenceRow.ChildType) ||
+                    (ComplexReferenceChildType.ComponentGroup == wixComplexReferenceRow.ChildType) ||
+                    (ComplexReferenceChildType.PatchFamilyGroup == wixComplexReferenceRow.ChildType))
+                {
+                    referencesToParent.RemoveAt(i);
+                }
+                else if (i > 0)
+                {
+                    // Since the list is already sorted, we can find duplicates by simply 
+                    // looking at the next sibling in the list and tossing out one if they
+                    // match.
+                    WixComplexReferenceRow crefCompare = (WixComplexReferenceRow)referencesToParent[i - 1];
+                    if (0 == wixComplexReferenceRow.CompareToWithoutConsideringPrimary(crefCompare))
+                    {
+                        referencesToParent.RemoveAt(i);
+                    }
+                }
+            }
+
+            loopDetector.Pop(); // pop this complex reference off the stack since we're done verify the loop here
+            parentGroupsNeedingProcessing.Remove(parentTypeAndId); // remove the newly processed complex reference
+        }
+
+        /*
+                /// <summary>
+                /// Debugging method for displaying the section complex references.
+                /// </summary>
+                /// <param name="header">The header.</param>
+                /// <param name="sections">The sections to display.</param>
+                private void DisplaySectionComplexReferences(string header, SectionCollection sections)
+                {
+                    Console.WriteLine(header);
+                    foreach (Section section in sections)
+                    {
+                        Table wixComplexReferenceTable = section.Tables["WixComplexReference"];
+
+                        foreach (WixComplexReferenceRow cref in wixComplexReferenceTable.Rows)
+                        {
+                            Console.WriteLine("Section: {0} Parent: {1} Type: {2} Child: {3} Primary: {4}", section.Id, cref.ParentId, cref.ParentType, cref.ChildId, cref.IsPrimary);
+                        }
+                    }
+                }
+        */
+
+        /// <summary>
+        /// Flattens the tables used in a Bundle.
+        /// </summary>
+        /// <param name="output">Output containing the tables to process.</param>
+        private void FlattenBundleTables(Output output)
+        {
+            if (OutputType.Bundle != output.Type)
+            {
+                return;
+            }
+
+            // We need to flatten the nested PayloadGroups and PackageGroups under
+            // UX, Chain, and any Containers.  When we're done, the WixGroups table
+            // will hold Payloads under UX, ChainPackages (references?) under Chain,
+            // and ChainPackages/Payloads under the attached and any detatched
+            // Containers.
+            WixGroupingOrdering groups = new WixGroupingOrdering(output, this);
+
+            // Create UX payloads and Package payloads
+            groups.UseTypes(new string[] { "Container", "Layout", "PackageGroup", "PayloadGroup", "Package" }, new string[] { "PackageGroup", "Package", "PayloadGroup", "Payload" });
+            groups.FlattenAndRewriteGroups("Package", false);
+            groups.FlattenAndRewriteGroups("Container", false);
+            groups.FlattenAndRewriteGroups("Layout", false);
+
+            // Create Chain packages...
+            groups.UseTypes(new string[] { "PackageGroup" }, new string[] { "Package", "PackageGroup" });
+            groups.FlattenAndRewriteRows("PackageGroup", "WixChain", false);
+
+            groups.RemoveUsedGroupRows();
+        }
+
+        /// <summary>
+        /// Resolves the features connected to other features in the active output.
+        /// </summary>
+        /// <param name="featuresToFeatures">Feature to feature complex references.</param>
+        /// <param name="allSymbols">All symbols loaded from the sections.</param>
+        private void ResolveFeatureToFeatureConnects(ConnectToFeatureCollection featuresToFeatures, IDictionary<string, Symbol> allSymbols)
+        {
+            foreach (ConnectToFeature connection in featuresToFeatures)
+            {
+                WixSimpleReferenceRow wixSimpleReferenceRow = new WixSimpleReferenceRow(null, this.tableDefinitions["WixSimpleReference"]);
+                wixSimpleReferenceRow.TableName = "Feature";
+                wixSimpleReferenceRow.PrimaryKeys = connection.ChildId;
+
+                Symbol symbol;
+                if (!allSymbols.TryGetValue(wixSimpleReferenceRow.SymbolicName, out symbol))
+                {
+                    continue;
+                }
+
+                Row row = symbol.Row;
+                row[1] = connection.PrimaryFeature;
+            }
+        }
+
+        /// <summary>
+        /// Copies a table's rows to an output table.
+        /// </summary>
+        /// <param name="table">Source table to copy rows from.</param>
+        /// <param name="outputTable">Destination table in output to copy rows into.</param>
+        /// <param name="sectionId">Id of the section that the table lives in.</param>
+        private void CopyTableRowsToOutputTable(Table table, Table outputTable, string sectionId)
+        {
+            int[] localizedColumns = new int[table.Definition.Columns.Count];
+            int localizedColumnCount = 0;
+
+            // if there are localization strings, figure out which columns can be localized in this table
+            if (null != this.localizer)
+            {
+                for (int i = 0; i < table.Definition.Columns.Count; i++)
+                {
+                    if (table.Definition.Columns[i].IsLocalizable)
+                    {
+                        localizedColumns[localizedColumnCount++] = i;
+                    }
+                }
+            }
+
+            // process each row in the table doing the string resource substitutions
+            // then add the row to the output
+            foreach (Row row in table.Rows)
+            {
+                for (int j = 0; j < localizedColumnCount; j++)
+                {
+                    Field field = row.Fields[localizedColumns[j]];
+
+                    if (null != field.Data)
+                    {
+                        field.Data = this.WixVariableResolver.ResolveVariables(row.SourceLineNumbers, (string)field.Data, true);
+                    }
+                }
+
+                row.SectionId = (this.sectionIdOnRows ? sectionId : null);
+                outputTable.Rows.Add(row);
+            }
+        }
+
+        /// <summary>
+        /// Set sequence numbers for all the actions and create rows in the output object.
+        /// </summary>
+        /// <param name="actionRows">Collection of actions to schedule.</param>
+        /// <param name="suppressActionRows">Collection of actions to suppress.</param>
+        private void SequenceActions(List<Row> actionRows, List<Row> suppressActionRows)
+        {
+            WixActionRowCollection overridableActionRows = new WixActionRowCollection();
+            WixActionRowCollection requiredActionRows = new WixActionRowCollection();
+            ArrayList scheduledActionRows = new ArrayList();
+
+            // gather the required actions for the output type
+            if (OutputType.Product == this.activeOutput.Type)
+            {
+                // AdminExecuteSequence table
+                overridableActionRows.Add(this.standardActions[SequenceTable.AdminExecuteSequence, "CostFinalize"]);
+                overridableActionRows.Add(this.standardActions[SequenceTable.AdminExecuteSequence, "CostInitialize"]);
+                overridableActionRows.Add(this.standardActions[SequenceTable.AdminExecuteSequence, "FileCost"]);
+                overridableActionRows.Add(this.standardActions[SequenceTable.AdminExecuteSequence, "InstallAdminPackage"]);
+                overridableActionRows.Add(this.standardActions[SequenceTable.AdminExecuteSequence, "InstallFiles"]);
+                overridableActionRows.Add(this.standardActions[SequenceTable.AdminExecuteSequence, "InstallFinalize"]);
+                overridableActionRows.Add(this.standardActions[SequenceTable.AdminExecuteSequence, "InstallInitialize"]);
+                overridableActionRows.Add(this.standardActions[SequenceTable.AdminExecuteSequence, "InstallValidate"]);
+
+                // AdminUISequence table
+                overridableActionRows.Add(this.standardActions[SequenceTable.AdminUISequence, "CostFinalize"]);
+                overridableActionRows.Add(this.standardActions[SequenceTable.AdminUISequence, "CostInitialize"]);
+                overridableActionRows.Add(this.standardActions[SequenceTable.AdminUISequence, "ExecuteAction"]);
+                overridableActionRows.Add(this.standardActions[SequenceTable.AdminUISequence, "FileCost"]);
+
+                // AdvtExecuteSequence table
+                overridableActionRows.Add(this.standardActions[SequenceTable.AdvtExecuteSequence, "CostFinalize"]);
+                overridableActionRows.Add(this.standardActions[SequenceTable.AdvtExecuteSequence, "CostInitialize"]);
+                overridableActionRows.Add(this.standardActions[SequenceTable.AdvtExecuteSequence, "InstallFinalize"]);
+                overridableActionRows.Add(this.standardActions[SequenceTable.AdvtExecuteSequence, "InstallInitialize"]);
+                overridableActionRows.Add(this.standardActions[SequenceTable.AdvtExecuteSequence, "InstallValidate"]);
+                overridableActionRows.Add(this.standardActions[SequenceTable.AdvtExecuteSequence, "PublishFeatures"]);
+                overridableActionRows.Add(this.standardActions[SequenceTable.AdvtExecuteSequence, "PublishProduct"]);
+
+                // InstallExecuteSequence table
+                overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "CostFinalize"]);
+                overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "CostInitialize"]);
+                overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "FileCost"]);
+                overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "InstallFinalize"]);
+                overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "InstallInitialize"]);
+                overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "InstallValidate"]);
+                overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "ProcessComponents"]);
+                overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "PublishFeatures"]);
+                overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "PublishProduct"]);
+                overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "RegisterProduct"]);
+                overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "RegisterUser"]);
+                overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "UnpublishFeatures"]);
+                overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "ValidateProductID"]);
+
+                // InstallUISequence table
+                overridableActionRows.Add(this.standardActions[SequenceTable.InstallUISequence, "CostFinalize"]);
+                overridableActionRows.Add(this.standardActions[SequenceTable.InstallUISequence, "CostInitialize"]);
+                overridableActionRows.Add(this.standardActions[SequenceTable.InstallUISequence, "ExecuteAction"]);
+                overridableActionRows.Add(this.standardActions[SequenceTable.InstallUISequence, "FileCost"]);
+                overridableActionRows.Add(this.standardActions[SequenceTable.InstallUISequence, "ValidateProductID"]);
+            }
+
+            // gather the required actions for each table
+            foreach (Table table in this.activeOutput.Tables)
+            {
+                switch (table.Name)
+                {
+                    case "AppSearch":
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "AppSearch"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallUISequence, "AppSearch"], true);
+                        break;
+                    case "BindImage":
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "BindImage"], true);
+                        break;
+                    case "CCPSearch":
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "AppSearch"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "CCPSearch"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "RMCCPSearch"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallUISequence, "AppSearch"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallUISequence, "CCPSearch"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallUISequence, "RMCCPSearch"], true);
+                        break;
+                    case "Class":
+                        overridableActionRows.Add(this.standardActions[SequenceTable.AdvtExecuteSequence, "RegisterClassInfo"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "RegisterClassInfo"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "UnregisterClassInfo"], true);
+                        break;
+                    case "Complus":
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "RegisterComPlus"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "UnregisterComPlus"], true);
+                        break;
+                    case "CreateFolder":
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "CreateFolders"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "RemoveFolders"], true);
+                        break;
+                    case "DuplicateFile":
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "DuplicateFiles"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "RemoveDuplicateFiles"], true);
+                        break;
+                    case "Environment":
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "WriteEnvironmentStrings"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "RemoveEnvironmentStrings"], true);
+                        break;
+                    case "Extension":
+                        overridableActionRows.Add(this.standardActions[SequenceTable.AdvtExecuteSequence, "RegisterExtensionInfo"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "RegisterExtensionInfo"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "UnregisterExtensionInfo"], true);
+                        break;
+                    case "File":
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "InstallFiles"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "RemoveFiles"], true);
+                        break;
+                    case "Font":
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "RegisterFonts"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "UnregisterFonts"], true);
+                        break;
+                    case "IniFile":
+                    case "RemoveIniFile":
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "WriteIniValues"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "RemoveIniValues"], true);
+                        break;
+                    case "IsolatedComponent":
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "IsolateComponents"], true);
+                        break;
+                    case "LaunchCondition":
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "LaunchConditions"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallUISequence, "LaunchConditions"], true);
+                        break;
+                    case "MIME":
+                        overridableActionRows.Add(this.standardActions[SequenceTable.AdvtExecuteSequence, "RegisterMIMEInfo"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "RegisterMIMEInfo"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "UnregisterMIMEInfo"], true);
+                        break;
+                    case "MoveFile":
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "MoveFiles"], true);
+                        break;
+                    case "MsiAssembly":
+                        overridableActionRows.Add(this.standardActions[SequenceTable.AdvtExecuteSequence, "MsiPublishAssemblies"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "MsiPublishAssemblies"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "MsiUnpublishAssemblies"], true);
+                        break;
+                    case "MsiServiceConfig":
+                    case "MsiServiceConfigFailureActions":
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "MsiConfigureServices"], true);
+                        break;
+                    case "ODBCDataSource":
+                    case "ODBCTranslator":
+                    case "ODBCDriver":
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "SetODBCFolders"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "InstallODBC"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "RemoveODBC"], true);
+                        break;
+                    case "ProgId":
+                        overridableActionRows.Add(this.standardActions[SequenceTable.AdvtExecuteSequence, "RegisterProgIdInfo"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "RegisterProgIdInfo"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "UnregisterProgIdInfo"], true);
+                        break;
+                    case "PublishComponent":
+                        overridableActionRows.Add(this.standardActions[SequenceTable.AdvtExecuteSequence, "PublishComponents"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "PublishComponents"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "UnpublishComponents"], true);
+                        break;
+                    case "Registry":
+                    case "RemoveRegistry":
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "WriteRegistryValues"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "RemoveRegistryValues"], true);
+                        break;
+                    case "RemoveFile":
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "RemoveFiles"], true);
+                        break;
+                    case "SelfReg":
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "SelfRegModules"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "SelfUnregModules"], true);
+                        break;
+                    case "ServiceControl":
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "StartServices"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "StopServices"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "DeleteServices"], true);
+                        break;
+                    case "ServiceInstall":
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "InstallServices"], true);
+                        break;
+                    case "Shortcut":
+                        overridableActionRows.Add(this.standardActions[SequenceTable.AdvtExecuteSequence, "CreateShortcuts"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "CreateShortcuts"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "RemoveShortcuts"], true);
+                        break;
+                    case "TypeLib":
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "RegisterTypeLibraries"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "UnregisterTypeLibraries"], true);
+                        break;
+                    case "Upgrade":
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "FindRelatedProducts"], true);
+                        overridableActionRows.Add(this.standardActions[SequenceTable.InstallUISequence, "FindRelatedProducts"], true);
+                        // Only add the MigrateFeatureStates action if MigrateFeature attribute is set to yes on at least one UpgradeVersion element.
+                        foreach (Row row in table.Rows)
+                        {
+                            int options = (int)row[4];
+                            if (MsiInterop.MsidbUpgradeAttributesMigrateFeatures == (options & MsiInterop.MsidbUpgradeAttributesMigrateFeatures))
+                            {
+                                overridableActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "MigrateFeatureStates"], true);
+                                overridableActionRows.Add(this.standardActions[SequenceTable.InstallUISequence, "MigrateFeatureStates"], true);
+                                break;
+                            }
+                        }
+                        break;
+                }
+            }
+
+            // index all the action rows (look for collisions)
+            foreach (WixActionRow actionRow in actionRows)
+            {
+                if (actionRow.Overridable) // overridable action
+                {
+                    WixActionRow collidingActionRow = overridableActionRows[actionRow.SequenceTable, actionRow.Action];
+
+                    if (null != collidingActionRow)
+                    {
+                        this.OnMessage(WixErrors.OverridableActionCollision(actionRow.SourceLineNumbers, actionRow.SequenceTable.ToString(), actionRow.Action));
+                        if (null != collidingActionRow.SourceLineNumbers)
+                        {
+                            this.OnMessage(WixErrors.OverridableActionCollision2(collidingActionRow.SourceLineNumbers));
+                        }
+                    }
+                    else
+                    {
+                        overridableActionRows.Add(actionRow);
+                    }
+                }
+                else // unscheduled/scheduled action
+                {
+                    // unscheduled action (allowed for certain standard actions)
+                    if (null == actionRow.Before && null == actionRow.After && 0 == actionRow.Sequence)
+                    {
+                        WixActionRow standardAction = this.standardActions[actionRow.SequenceTable, actionRow.Action];
+
+                        if (null != standardAction)
+                        {
+                            // populate the sequence from the standard action
+                            actionRow.Sequence = standardAction.Sequence;
+                        }
+                        else // not a supported unscheduled action
+                        {
+                            throw new InvalidOperationException(WixStrings.EXP_FoundActionRowWithNoSequenceBeforeOrAfterColumnSet);
+                        }
+                    }
+
+                    WixActionRow collidingActionRow = requiredActionRows[actionRow.SequenceTable, actionRow.Action];
+
+                    if (null != collidingActionRow)
+                    {
+                        this.OnMessage(WixErrors.ActionCollision(actionRow.SourceLineNumbers, actionRow.SequenceTable.ToString(), actionRow.Action));
+                        if (null != collidingActionRow.SourceLineNumbers)
+                        {
+                            this.OnMessage(WixErrors.ActionCollision2(collidingActionRow.SourceLineNumbers));
+                        }
+                    }
+                    else
+                    {
+                        requiredActionRows.Add(actionRow.Clone());
+                    }
+                }
+            }
+
+            // add the overridable action rows that are not overridden to the required action rows
+            foreach (WixActionRow actionRow in overridableActionRows)
+            {
+                if (null == requiredActionRows[actionRow.SequenceTable, actionRow.Action])
+                {
+                    requiredActionRows.Add(actionRow.Clone());
+                }
+            }
+
+            // suppress the required actions that are overridable
+            foreach (Row suppressActionRow in suppressActionRows)
+            {
+                SequenceTable sequenceTable = (SequenceTable)Enum.Parse(typeof(SequenceTable), (string)suppressActionRow[0]);
+                string action = (string)suppressActionRow[1];
+
+                // get the action being suppressed (if it exists)
+                WixActionRow requiredActionRow = requiredActionRows[sequenceTable, action];
+
+                // if there is an overridable row to suppress; suppress it
+                // there is no warning if there is no action to suppress because the action may be suppressed from a merge module in the binder
+                if (null != requiredActionRow)
+                {
+                    if (requiredActionRow.Overridable)
+                    {
+                        this.OnMessage(WixWarnings.SuppressAction(suppressActionRow.SourceLineNumbers, action, sequenceTable.ToString()));
+                        if (null != requiredActionRow.SourceLineNumbers)
+                        {
+                            this.OnMessage(WixWarnings.SuppressAction2(requiredActionRow.SourceLineNumbers));
+                        }
+                        requiredActionRows.Remove(sequenceTable, action);
+                    }
+                    else // suppressing a non-overridable action row
+                    {
+                        this.OnMessage(WixErrors.SuppressNonoverridableAction(suppressActionRow.SourceLineNumbers, sequenceTable.ToString(), action));
+                        if (null != requiredActionRow.SourceLineNumbers)
+                        {
+                            this.OnMessage(WixErrors.SuppressNonoverridableAction2(requiredActionRow.SourceLineNumbers));
+                        }
+                    }
+                }
+            }
+
+            // create a copy of the required action rows so that new rows can be added while enumerating
+            WixActionRow[] copyOfRequiredActionRows = new WixActionRow[requiredActionRows.Count];
+            requiredActionRows.CopyTo(copyOfRequiredActionRows, 0);
+
+            // build up dependency trees of the relatively scheduled actions
+            foreach (WixActionRow actionRow in copyOfRequiredActionRows)
+            {
+                if (0 == actionRow.Sequence)
+                {
+                    // check for standard actions that don't have a sequence number in a merge module
+                    if (OutputType.Module == this.activeOutput.Type && WindowsInstallerStandard.IsStandardAction(actionRow.Action))
+                    {
+                        this.OnMessage(WixErrors.StandardActionRelativelyScheduledInModule(actionRow.SourceLineNumbers, actionRow.SequenceTable.ToString(), actionRow.Action));
+                    }
+
+                    this.SequenceActionRow(actionRow, requiredActionRows);
+                }
+                else if (OutputType.Module == this.activeOutput.Type && 0 < actionRow.Sequence && !WindowsInstallerStandard.IsStandardAction(actionRow.Action)) // check for custom actions and dialogs that have a sequence number
+                {
+                    this.OnMessage(WixErrors.CustomActionSequencedInModule(actionRow.SourceLineNumbers, actionRow.SequenceTable.ToString(), actionRow.Action));
+                }
+            }
+
+            // look for standard actions with sequence restrictions that aren't necessarily scheduled based on the presence of a particular table
+            if (requiredActionRows.Contains(SequenceTable.InstallExecuteSequence, "DuplicateFiles") && !requiredActionRows.Contains(SequenceTable.InstallExecuteSequence, "InstallFiles"))
+            {
+                requiredActionRows.Add(this.standardActions[SequenceTable.InstallExecuteSequence, "InstallFiles"], true);
+            }
+
+            // schedule actions
+            if (OutputType.Module == this.activeOutput.Type)
+            {
+                // add the action row to the list of scheduled action rows
+                scheduledActionRows.AddRange(requiredActionRows);
+            }
+            else
+            {
+                // process each sequence table individually
+                foreach (SequenceTable sequenceTable in Enum.GetValues(typeof(SequenceTable)))
+                {
+                    // create a collection of just the action rows in this sequence
+                    WixActionRowCollection sequenceActionRows = new WixActionRowCollection();
+                    foreach (WixActionRow actionRow in requiredActionRows)
+                    {
+                        if (sequenceTable == actionRow.SequenceTable)
+                        {
+                            sequenceActionRows.Add(actionRow);
+                        }
+                    }
+
+                    // schedule the absolutely scheduled actions (by sorting them by their sequence numbers)
+                    ArrayList absoluteActionRows = new ArrayList();
+                    foreach (WixActionRow actionRow in sequenceActionRows)
+                    {
+                        if (0 != actionRow.Sequence)
+                        {
+                            // look for sequence number collisions
+                            foreach (WixActionRow sequenceScheduledActionRow in absoluteActionRows)
+                            {
+                                if (sequenceScheduledActionRow.Sequence == actionRow.Sequence)
+                                {
+                                    this.OnMessage(WixWarnings.ActionSequenceCollision(actionRow.SourceLineNumbers, actionRow.SequenceTable.ToString(), actionRow.Action, sequenceScheduledActionRow.Action, actionRow.Sequence));
+                                    if (null != sequenceScheduledActionRow.SourceLineNumbers)
+                                    {
+                                        this.OnMessage(WixWarnings.ActionSequenceCollision2(sequenceScheduledActionRow.SourceLineNumbers));
+                                    }
+                                }
+                            }
+
+                            absoluteActionRows.Add(actionRow);
+                        }
+                    }
+                    absoluteActionRows.Sort();
+
+                    // schedule the relatively scheduled actions (by resolving the dependency trees)
+                    int previousUsedSequence = 0;
+                    ArrayList relativeActionRows = new ArrayList();
+                    for (int j = 0; j < absoluteActionRows.Count; j++)
+                    {
+                        WixActionRow absoluteActionRow = (WixActionRow)absoluteActionRows[j];
+                        int unusedSequence;
+
+                        // get all the relatively scheduled action rows occuring before this absolutely scheduled action row
+                        RowIndexedList<WixActionRow> allPreviousActionRows = new RowIndexedList<WixActionRow>();
+                        absoluteActionRow.GetAllPreviousActionRows(sequenceTable, allPreviousActionRows);
+
+                        // get all the relatively scheduled action rows occuring after this absolutely scheduled action row
+                        RowIndexedList<WixActionRow> allNextActionRows = new RowIndexedList<WixActionRow>();
+                        absoluteActionRow.GetAllNextActionRows(sequenceTable, allNextActionRows);
+
+                        // check for relatively scheduled actions occuring before/after a special action (these have a negative sequence number)
+                        if (0 > absoluteActionRow.Sequence && (0 < allPreviousActionRows.Count || 0 < allNextActionRows.Count))
+                        {
+                            // create errors for all the before actions
+                            foreach (WixActionRow actionRow in allPreviousActionRows)
+                            {
+                                this.OnMessage(WixErrors.ActionScheduledRelativeToTerminationAction(actionRow.SourceLineNumbers, actionRow.SequenceTable.ToString(), actionRow.Action, absoluteActionRow.Action));
+                            }
+
+                            // create errors for all the after actions
+                            foreach (WixActionRow actionRow in allNextActionRows)
+                            {
+                                this.OnMessage(WixErrors.ActionScheduledRelativeToTerminationAction(actionRow.SourceLineNumbers, actionRow.SequenceTable.ToString(), actionRow.Action, absoluteActionRow.Action));
+                            }
+
+                            // if there is source line information for the absolutely scheduled action display it
+                            if (null != absoluteActionRow.SourceLineNumbers)
+                            {
+                                this.OnMessage(WixErrors.ActionScheduledRelativeToTerminationAction2(absoluteActionRow.SourceLineNumbers));
+                            }
+
+                            continue;
+                        }
+
+                        // schedule the action rows before this one
+                        unusedSequence = absoluteActionRow.Sequence - 1;
+                        for (int i = allPreviousActionRows.Count - 1; i >= 0; i--)
+                        {
+                            WixActionRow relativeActionRow = (WixActionRow)allPreviousActionRows[i];
+
+                            // look for collisions
+                            if (unusedSequence == previousUsedSequence)
+                            {
+                                this.OnMessage(WixErrors.NoUniqueActionSequenceNumber(relativeActionRow.SourceLineNumbers, relativeActionRow.SequenceTable.ToString(), relativeActionRow.Action, absoluteActionRow.Action));
+                                if (null != absoluteActionRow.SourceLineNumbers)
+                                {
+                                    this.OnMessage(WixErrors.NoUniqueActionSequenceNumber2(absoluteActionRow.SourceLineNumbers));
+                                }
+
+                                unusedSequence++;
+                            }
+
+                            relativeActionRow.Sequence = unusedSequence;
+                            relativeActionRows.Add(relativeActionRow);
+
+                            unusedSequence--;
+                        }
+
+                        // determine the next used action sequence number
+                        int nextUsedSequence;
+                        if (absoluteActionRows.Count > j + 1)
+                        {
+                            nextUsedSequence = ((WixActionRow)absoluteActionRows[j + 1]).Sequence;
+                        }
+                        else
+                        {
+                            nextUsedSequence = short.MaxValue + 1;
+                        }
+
+                        // schedule the action rows after this one
+                        unusedSequence = absoluteActionRow.Sequence + 1;
+                        for (int i = 0; i < allNextActionRows.Count; i++)
+                        {
+                            WixActionRow relativeActionRow = (WixActionRow)allNextActionRows[i];
+
+                            if (unusedSequence == nextUsedSequence)
+                            {
+                                this.OnMessage(WixErrors.NoUniqueActionSequenceNumber(relativeActionRow.SourceLineNumbers, relativeActionRow.SequenceTable.ToString(), relativeActionRow.Action, absoluteActionRow.Action));
+                                if (null != absoluteActionRow.SourceLineNumbers)
+                                {
+                                    this.OnMessage(WixErrors.NoUniqueActionSequenceNumber2(absoluteActionRow.SourceLineNumbers));
+                                }
+
+                                unusedSequence--;
+                            }
+
+                            relativeActionRow.Sequence = unusedSequence;
+                            relativeActionRows.Add(relativeActionRow);
+
+                            unusedSequence++;
+                        }
+
+                        // keep track of this sequence number as the previous used sequence number for the next iteration
+                        previousUsedSequence = absoluteActionRow.Sequence;
+                    }
+
+                    // add the absolutely and relatively scheduled actions to the list of scheduled actions
+                    scheduledActionRows.AddRange(absoluteActionRows);
+                    scheduledActionRows.AddRange(relativeActionRows);
+                }
+            }
+
+            // create the action rows for sequences that are not suppressed
+            foreach (WixActionRow actionRow in scheduledActionRows)
+            {
+                // get the table definition for the action (and ensure the proper table exists for a module)
+                TableDefinition sequenceTableDefinition = null;
+                switch (actionRow.SequenceTable)
+                {
+                    case SequenceTable.AdminExecuteSequence:
+                        if (OutputType.Module == this.activeOutput.Type)
+                        {
+                            this.activeOutput.EnsureTable(this.tableDefinitions["AdminExecuteSequence"]);
+                            sequenceTableDefinition = this.tableDefinitions["ModuleAdminExecuteSequence"];
+                        }
+                        else
+                        {
+                            sequenceTableDefinition = this.tableDefinitions["AdminExecuteSequence"];
+                        }
+                        break;
+                    case SequenceTable.AdminUISequence:
+                        if (OutputType.Module == this.activeOutput.Type)
+                        {
+                            this.activeOutput.EnsureTable(this.tableDefinitions["AdminUISequence"]);
+                            sequenceTableDefinition = this.tableDefinitions["ModuleAdminUISequence"];
+                        }
+                        else
+                        {
+                            sequenceTableDefinition = this.tableDefinitions["AdminUISequence"];
+                        }
+                        break;
+                    case SequenceTable.AdvtExecuteSequence:
+                        if (OutputType.Module == this.activeOutput.Type)
+                        {
+                            this.activeOutput.EnsureTable(this.tableDefinitions["AdvtExecuteSequence"]);
+                            sequenceTableDefinition = this.tableDefinitions["ModuleAdvtExecuteSequence"];
+                        }
+                        else
+                        {
+                            sequenceTableDefinition = this.tableDefinitions["AdvtExecuteSequence"];
+                        }
+                        break;
+                    case SequenceTable.InstallExecuteSequence:
+                        if (OutputType.Module == this.activeOutput.Type)
+                        {
+                            this.activeOutput.EnsureTable(this.tableDefinitions["InstallExecuteSequence"]);
+                            sequenceTableDefinition = this.tableDefinitions["ModuleInstallExecuteSequence"];
+                        }
+                        else
+                        {
+                            sequenceTableDefinition = this.tableDefinitions["InstallExecuteSequence"];
+                        }
+                        break;
+                    case SequenceTable.InstallUISequence:
+                        if (OutputType.Module == this.activeOutput.Type)
+                        {
+                            this.activeOutput.EnsureTable(this.tableDefinitions["InstallUISequence"]);
+                            sequenceTableDefinition = this.tableDefinitions["ModuleInstallUISequence"];
+                        }
+                        else
+                        {
+                            sequenceTableDefinition = this.tableDefinitions["InstallUISequence"];
+                        }
+                        break;
+                }
+
+                // create the action sequence row in the output
+                Table sequenceTable = this.activeOutput.EnsureTable(sequenceTableDefinition);
+                Row row = sequenceTable.CreateRow(actionRow.SourceLineNumbers);
+                if (this.sectionIdOnRows)
+                {
+                    row.SectionId = actionRow.SectionId;
+                }
+
+                if (OutputType.Module == this.activeOutput.Type)
+                {
+                    row[0] = actionRow.Action;
+                    if (0 != actionRow.Sequence)
+                    {
+                        row[1] = actionRow.Sequence;
+                    }
+                    else
+                    {
+                        bool after = (null == actionRow.Before);
+                        row[2] = after ? actionRow.After : actionRow.Before;
+                        row[3] = after ? 1 : 0;
+                    }
+                    row[4] = actionRow.Condition;
+                }
+                else
+                {
+                    row[0] = actionRow.Action;
+                    row[1] = actionRow.Condition;
+                    row[2] = actionRow.Sequence;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Sequence an action before or after a standard action.
+        /// </summary>
+        /// <param name="actionRow">The action row to be sequenced.</param>
+        /// <param name="requiredActionRows">Collection of actions which must be included.</param>
+        [SuppressMessage("Microsoft.Globalization", "CA1303:DoNotPassLiteralsAsLocalizedParameters", MessageId = "System.InvalidOperationException.#ctor(System.String)")]
+        private void SequenceActionRow(WixActionRow actionRow, WixActionRowCollection requiredActionRows)
+        {
+            bool after = false;
+            if (actionRow.After != null)
+            {
+                after = true;
+            }
+            else if (actionRow.Before == null)
+            {
+                throw new InvalidOperationException(WixStrings.EXP_FoundActionRowWithNoSequenceBeforeOrAfterColumnSet);
+            }
+
+            string parentActionName = (after ? actionRow.After : actionRow.Before);
+            WixActionRow parentActionRow = requiredActionRows[actionRow.SequenceTable, parentActionName];
+
+            if (null == parentActionRow)
+            {
+                parentActionRow = this.standardActions[actionRow.SequenceTable, parentActionName];
+
+                // if the missing parent action is a standard action (with a suggested sequence number), add it
+                if (null != parentActionRow)
+                {
+                    // Create a clone to avoid modifying the static copy of the object.
+                    parentActionRow = parentActionRow.Clone();
+                    requiredActionRows.Add(parentActionRow);
+                }
+                else
+                {
+                    throw new InvalidOperationException(String.Format(CultureInfo.CurrentUICulture, WixStrings.EXP_FoundActionRowWinNonExistentAction, (after ? "After" : "Before"), parentActionName));
+                }
+            }
+            else if (actionRow == parentActionRow || actionRow.ContainsChildActionRow(parentActionRow)) // cycle detected
+            {
+                throw new WixException(WixErrors.ActionCircularDependency(actionRow.SourceLineNumbers, actionRow.SequenceTable.ToString(), actionRow.Action, parentActionRow.Action));
+            }
+
+            // Add this action to the appropriate list of dependent action rows.
+            WixActionRowCollection relatedRows = (after ? parentActionRow.NextActionRows : parentActionRow.PreviousActionRows);
+            relatedRows.Add(actionRow);
+        }
+
+        /// <summary>
+        /// Resolve features for columns that have null guid placeholders.
+        /// </summary>
+        /// <param name="rows">Rows to resolve.</param>
+        /// <param name="connectionColumn">Number of the column containing the connection identifier.</param>
+        /// <param name="featureColumn">Number of the column containing the feature.</param>
+        /// <param name="connectToFeatures">Connect to feature complex references.</param>
+        /// <param name="multipleFeatureComponents">Hashtable of known components under multiple features.</param>
+        private void ResolveFeatures(IEnumerable<Row> rows, int connectionColumn, int featureColumn, ConnectToFeatureCollection connectToFeatures, Hashtable multipleFeatureComponents)
+        {
+            foreach (Row row in rows)
+            {
+                string connectionId = (string)row[connectionColumn];
+                string featureId = (string)row[featureColumn];
+
+                if (emptyGuid == featureId)
+                {
+                    ConnectToFeature connection = connectToFeatures[connectionId];
+
+                    if (null == connection)
+                    {
+                        // display an error for the component or merge module as approrpriate
+                        if (null != multipleFeatureComponents)
+                        {
+                            this.OnMessage(WixErrors.ComponentExpectedFeature(row.SourceLineNumbers, connectionId, row.Table.Name, row.GetPrimaryKey('/')));
+                        }
+                        else
+                        {
+                            this.OnMessage(WixErrors.MergeModuleExpectedFeature(row.SourceLineNumbers, connectionId));
+                        }
+                    }
+                    else
+                    {
+                        // check for unique, implicit, primary feature parents with multiple possible parent features
+                        if (this.ShowPedanticMessages &&
+                            !connection.IsExplicitPrimaryFeature &&
+                            0 < connection.ConnectFeatures.Count)
+                        {
+                            // display a warning for the component or merge module as approrpriate
+                            if (null != multipleFeatureComponents)
+                            {
+                                if (!multipleFeatureComponents.Contains(connectionId))
+                                {
+                                    this.OnMessage(WixWarnings.ImplicitComponentPrimaryFeature(connectionId));
+
+                                    // remember this component so only one warning is generated for it
+                                    multipleFeatureComponents[connectionId] = null;
+                                }
+                            }
+                            else
+                            {
+                                this.OnMessage(WixWarnings.ImplicitMergeModulePrimaryFeature(connectionId));
+                            }
+                        }
+
+                        // set the feature
+                        row[featureColumn] = connection.PrimaryFeature;
+                    }
+                }
+            }
+        }
+
+    }
+}
diff --git a/src/WixToolset.Core/Localizer.cs b/src/WixToolset.Core/Localizer.cs
new file mode 100644
index 00000000..3c299896
--- /dev/null
+++ b/src/WixToolset.Core/Localizer.cs
@@ -0,0 +1,384 @@
+// 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
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Xml.Linq;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+    using WixToolset.Core.Native;
+
+    /// <summary>
+    /// Parses localization files and localizes database values.
+    /// </summary>
+    public sealed class Localizer
+    {
+        public static readonly XNamespace WxlNamespace = "http://wixtoolset.org/schemas/v4/wxl";
+        private static string XmlElementName = "WixLocalization";
+
+        private Dictionary<string, WixVariableRow> variables;
+        private Dictionary<string, LocalizedControl> localizedControls;
+
+        /// <summary>
+        /// Instantiate a new Localizer.
+        /// </summary>
+        public Localizer()
+        {
+            this.Codepage = -1;
+            this.variables = new Dictionary<string,WixVariableRow>();
+            this.localizedControls = new Dictionary<string, LocalizedControl>();
+        }
+
+        /// <summary>
+        /// Gets the codepage.
+        /// </summary>
+        /// <value>The codepage.</value>
+        public int Codepage { get; private set; }
+
+        /// <summary>
+        /// Loads a localization file from a path on disk.
+        /// </summary>
+        /// <param name="path">Path to library file saved on disk.</param>
+        /// <param name="tableDefinitions">Collection containing TableDefinitions to use when loading the localization file.</param>
+        /// <param name="suppressSchema">Suppress xml schema validation while loading.</param>
+        /// <returns>Returns the loaded localization file.</returns>
+        public static Localization ParseLocalizationFile(string path, TableDefinitionCollection tableDefinitions)
+        {
+            XElement root = XDocument.Load(path).Root;
+            Localization localization = null;
+
+            SourceLineNumber sourceLineNumbers = SourceLineNumber.CreateFromXObject(root);
+            if (Localizer.XmlElementName == root.Name.LocalName)
+            {
+                if (Localizer.WxlNamespace == root.Name.Namespace)
+                {
+                    localization = ParseWixLocalizationElement(root, tableDefinitions);
+                }
+                else // invalid or missing namespace
+                {
+                    if (null == root.Name.Namespace)
+                    {
+                        Messaging.Instance.OnMessage(WixErrors.InvalidWixXmlNamespace(sourceLineNumbers, Localizer.XmlElementName, Localizer.WxlNamespace.NamespaceName));
+                    }
+                    else
+                    {
+                        Messaging.Instance.OnMessage(WixErrors.InvalidWixXmlNamespace(sourceLineNumbers, Localizer.XmlElementName, root.Name.LocalName, Localizer.WxlNamespace.NamespaceName));
+                    }
+                }
+            }
+            else
+            {
+                Messaging.Instance.OnMessage(WixErrors.InvalidDocumentElement(sourceLineNumbers, root.Name.LocalName, "localization", Localizer.XmlElementName));
+            }
+
+            return localization;
+        }
+
+        /// <summary>
+        /// Add a localization file.
+        /// </summary>
+        /// <param name="localization">The localization file to add.</param>
+        public void AddLocalization(Localization localization)
+        {
+            if (-1 == this.Codepage)
+            {
+                this.Codepage = localization.Codepage;
+            }
+
+            foreach (WixVariableRow wixVariableRow in localization.Variables)
+            {
+                Localizer.AddWixVariable(this.variables, wixVariableRow);
+            }
+
+            foreach (KeyValuePair<string, LocalizedControl> localizedControl in localization.LocalizedControls)
+            {
+                if (!this.localizedControls.ContainsKey(localizedControl.Key))
+                {
+                    this.localizedControls.Add(localizedControl.Key, localizedControl.Value);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Get a localized data value.
+        /// </summary>
+        /// <param name="id">The name of the localization variable.</param>
+        /// <returns>The localized data value or null if it wasn't found.</returns>
+        public string GetLocalizedValue(string id)
+        {
+            WixVariableRow wixVariableRow;
+            return this.variables.TryGetValue(id, out wixVariableRow) ? wixVariableRow.Value : null;
+        }
+
+        /// <summary>
+        /// Get a localized control.
+        /// </summary>
+        /// <param name="dialog">The optional id of the control's dialog.</param>
+        /// <param name="control">The id of the control.</param>
+        /// <returns>The localized control or null if it wasn't found.</returns>
+        public LocalizedControl GetLocalizedControl(string dialog, string control)
+        {
+            LocalizedControl localizedControl;
+            return this.localizedControls.TryGetValue(LocalizedControl.GetKey(dialog, control), out localizedControl) ? localizedControl : null;
+        }
+
+        /// <summary>
+        /// Adds a WixVariableRow to a dictionary while performing the expected override checks.
+        /// </summary>
+        /// <param name="variables">Dictionary of variable rows.</param>
+        /// <param name="wixVariableRow">Row to add to the variables dictionary.</param>
+        private static void AddWixVariable(IDictionary<string, WixVariableRow> variables, WixVariableRow wixVariableRow)
+        {
+            WixVariableRow existingWixVariableRow;
+            if (!variables.TryGetValue(wixVariableRow.Id, out existingWixVariableRow) || (existingWixVariableRow.Overridable && !wixVariableRow.Overridable))
+            {
+                variables[wixVariableRow.Id] = wixVariableRow;
+            }
+            else if (!wixVariableRow.Overridable)
+            {
+                Messaging.Instance.OnMessage(WixErrors.DuplicateLocalizationIdentifier(wixVariableRow.SourceLineNumbers, wixVariableRow.Id));
+            }
+        }
+
+        /// <summary>
+        /// Parses the WixLocalization element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        private static Localization ParseWixLocalizationElement(XElement node, TableDefinitionCollection tableDefinitions)
+        {
+            int codepage = -1;
+            string culture = null;
+            SourceLineNumber sourceLineNumbers = SourceLineNumber.CreateFromXObject(node);
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || Localizer.WxlNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Codepage":
+                            codepage = Common.GetValidCodePage(attrib.Value, true, false, sourceLineNumbers);
+                            break;
+                        case "Culture":
+                            culture = attrib.Value;
+                            break;
+                        case "Language":
+                            // do nothing; @Language is used for locutil which can't convert Culture to lcid
+                            break;
+                        default:
+                            Common.UnexpectedAttribute(sourceLineNumbers, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    Common.UnexpectedAttribute(sourceLineNumbers, attrib);
+                }
+            }
+
+            Dictionary<string, WixVariableRow> variables = new Dictionary<string,WixVariableRow>();
+            Dictionary<string, LocalizedControl> localizedControls = new Dictionary<string, LocalizedControl>();
+
+            foreach (XElement child in node.Elements())
+            {
+                if (Localizer.WxlNamespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "String":
+                            Localizer.ParseString(child, variables, tableDefinitions);
+                            break;
+
+                        case "UI":
+                            Localizer.ParseUI(child, localizedControls);
+                            break;
+
+                        default:
+                            Messaging.Instance.OnMessage(WixErrors.UnexpectedElement(sourceLineNumbers, node.Name.ToString(), child.Name.ToString()));
+                            break;
+                    }
+                }
+                else
+                {
+                    Messaging.Instance.OnMessage(WixErrors.UnsupportedExtensionElement(sourceLineNumbers, node.Name.ToString(), child.Name.ToString()));
+                }
+            }
+
+            return Messaging.Instance.EncounteredError ? null : new Localization(codepage, culture, variables, localizedControls);
+        }
+
+        /// <summary>
+        /// Parse a localization string into a WixVariableRow.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        private static void ParseString(XElement node, IDictionary<string, WixVariableRow> variables, TableDefinitionCollection tableDefinitions)
+        {
+            string id = null;
+            bool overridable = false;
+            SourceLineNumber sourceLineNumbers = SourceLineNumber.CreateFromXObject(node);
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || Localizer.WxlNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = Common.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Overridable":
+                            overridable = YesNoType.Yes == Common.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Localizable":
+                            ; // do nothing
+                            break;
+                        default:
+                            Messaging.Instance.OnMessage(WixErrors.UnexpectedAttribute(sourceLineNumbers, attrib.Parent.Name.ToString(), attrib.Name.ToString()));
+                            break;
+                    }
+                }
+                else
+                {
+                    Messaging.Instance.OnMessage(WixErrors.UnsupportedExtensionAttribute(sourceLineNumbers, attrib.Parent.Name.ToString(), attrib.Name.ToString()));
+                }
+            }
+
+            string value = Common.GetInnerText(node);
+
+            if (null == id)
+            {
+                Messaging.Instance.OnMessage(WixErrors.ExpectedAttribute(sourceLineNumbers, "String", "Id"));
+            }
+            else if (0 == id.Length)
+            {
+                Messaging.Instance.OnMessage(WixErrors.IllegalIdentifier(sourceLineNumbers, "String", "Id", 0));
+            }
+
+            if (!Messaging.Instance.EncounteredError)
+            {
+                WixVariableRow wixVariableRow = new WixVariableRow(sourceLineNumbers, tableDefinitions["WixVariable"]);
+                wixVariableRow.Id = id;
+                wixVariableRow.Overridable = overridable;
+                wixVariableRow.Value = value;
+
+                Localizer.AddWixVariable(variables, wixVariableRow);
+            }
+        }
+
+        /// <summary>
+        /// Parse a localized control.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="localizedControls">Dictionary of localized controls.</param>
+        private static void ParseUI(XElement node, IDictionary<string, LocalizedControl> localizedControls)
+        {
+            string dialog = null;
+            string control = null;
+            int x = CompilerConstants.IntegerNotSet;
+            int y = CompilerConstants.IntegerNotSet;
+            int width = CompilerConstants.IntegerNotSet;
+            int height = CompilerConstants.IntegerNotSet;
+            int attribs = 0;
+            string text = null;
+            SourceLineNumber sourceLineNumbers = SourceLineNumber.CreateFromXObject(node);
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || Localizer.WxlNamespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Dialog":
+                            dialog = Common.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Control":
+                            control = Common.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        case "X":
+                            x = Common.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, short.MaxValue);
+                            break;
+                        case "Y":
+                            y = Common.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, short.MaxValue);
+                            break;
+                        case "Width":
+                            width = Common.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, short.MaxValue);
+                            break;
+                        case "Height":
+                            height = Common.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, short.MaxValue);
+                            break;
+                        case "RightToLeft":
+                            if (YesNoType.Yes == Common.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attribs |= MsiInterop.MsidbControlAttributesRTLRO;
+                            }
+                            break;
+                        case "RightAligned":
+                            if (YesNoType.Yes == Common.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attribs |= MsiInterop.MsidbControlAttributesRightAligned;
+                            }
+                            break;
+                        case "LeftScroll":
+                            if (YesNoType.Yes == Common.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attribs |= MsiInterop.MsidbControlAttributesLeftScroll;
+                            }
+                            break;
+                        default:
+                            Common.UnexpectedAttribute(sourceLineNumbers, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    Common.UnexpectedAttribute(sourceLineNumbers, attrib);
+                }
+            }
+
+            text = Common.GetInnerText(node);
+
+            if (String.IsNullOrEmpty(control) && 0 < attribs)
+            {
+                if (MsiInterop.MsidbControlAttributesRTLRO == (attribs & MsiInterop.MsidbControlAttributesRTLRO))
+                {
+                    Messaging.Instance.OnMessage(WixErrors.IllegalAttributeWithoutOtherAttributes(sourceLineNumbers, node.Name.ToString(), "RightToLeft", "Control"));
+                }
+                else if (MsiInterop.MsidbControlAttributesRightAligned == (attribs & MsiInterop.MsidbControlAttributesRightAligned))
+                {
+                    Messaging.Instance.OnMessage(WixErrors.IllegalAttributeWithoutOtherAttributes(sourceLineNumbers, node.Name.ToString(), "RightAligned", "Control"));
+                }
+                else if (MsiInterop.MsidbControlAttributesLeftScroll == (attribs & MsiInterop.MsidbControlAttributesLeftScroll))
+                {
+                    Messaging.Instance.OnMessage(WixErrors.IllegalAttributeWithoutOtherAttributes(sourceLineNumbers, node.Name.ToString(), "LeftScroll", "Control"));
+                }
+            }
+
+            if (String.IsNullOrEmpty(control) && String.IsNullOrEmpty(dialog))
+            {
+                Messaging.Instance.OnMessage(WixErrors.ExpectedAttributesWithOtherAttribute(sourceLineNumbers, node.Name.ToString(), "Dialog", "Control"));
+            }
+
+            if (!Messaging.Instance.EncounteredError)
+            {
+                LocalizedControl localizedControl = new LocalizedControl(dialog, control, x, y, width, height, attribs, text);
+                string key = localizedControl.GetKey();
+                if (localizedControls.ContainsKey(key))
+                {
+                    if (String.IsNullOrEmpty(localizedControl.Control))
+                    {
+                        Messaging.Instance.OnMessage(WixErrors.DuplicatedUiLocalization(sourceLineNumbers, localizedControl.Dialog));
+                    }
+                    else
+                    {
+                        Messaging.Instance.OnMessage(WixErrors.DuplicatedUiLocalization(sourceLineNumbers, localizedControl.Dialog, localizedControl.Control));
+                    }
+                }
+                else
+                {
+                    localizedControls.Add(key, localizedControl);
+                }
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Melter.cs b/src/WixToolset.Core/Melter.cs
new file mode 100644
index 00000000..ccc0cb6f
--- /dev/null
+++ b/src/WixToolset.Core/Melter.cs
@@ -0,0 +1,398 @@
+// 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
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Collections.Specialized;
+    using System.Globalization;
+    using System.IO;
+    using System.Text;
+    using System.Text.RegularExpressions;
+    using WixToolset.Data;
+    using Wix = WixToolset.Data.Serialize;
+
+    /// <summary>
+    /// Converts a wixout representation of an MSM database into a ComponentGroup the form of WiX source.
+    /// </summary>
+    public sealed class Melter
+    {
+        private MelterCore core;
+        private Decompiler decompiler;
+
+        private Wix.ComponentGroup componentGroup;
+        private Wix.DirectoryRef primaryDirectoryRef;
+        private Wix.Fragment fragment;
+
+        private string id;
+        private string moduleId;
+        private const string nullGuid = "{00000000-0000-0000-0000-000000000000}";
+
+        public string Id
+        {
+            get { return this.id; }
+            set { this.id = value; }
+        }
+
+        public Decompiler Decompiler
+        {
+            get { return this.decompiler; }
+            set { this.decompiler = value; }
+        }
+
+        /// <summary>
+        /// Creates a new melter object.
+        /// </summary>
+        /// <param name="decompiler">The decompiler to use during the melting process.</param>
+        /// <param name="id">The Id to use for the ComponentGroup, DirectoryRef, and WixVariables. If null, defaults to the Module's Id</param>
+        public Melter(Decompiler decompiler, string id)
+        {
+            this.core = new MelterCore();
+
+            this.componentGroup = new Wix.ComponentGroup();
+            this.fragment = new Wix.Fragment();
+            this.primaryDirectoryRef = new Wix.DirectoryRef();
+
+            this.decompiler = decompiler;
+            this.id = id;
+
+            if (null == this.decompiler)
+            {
+                this.core.OnMessage(WixErrors.ExpectedDecompiler("The melting process"));
+            }
+        }
+
+        /// <summary>
+        /// Converts a Module wixout into a ComponentGroup.
+        /// </summary>
+        /// <param name="wixout">The output object representing the unbound merge module to melt.</param>
+        /// <returns>The converted Module as a ComponentGroup.</returns>
+        public Wix.Wix Melt(Output wixout)
+        {
+            this.moduleId = GetModuleId(wixout);
+
+            // Assign the default componentGroupId if none was specified
+            if (null == this.id)
+            {
+                this.id = this.moduleId;
+            }
+
+            this.componentGroup.Id = this.id;
+            this.primaryDirectoryRef.Id = this.id;
+
+            PreDecompile(wixout);
+
+            wixout.Type = OutputType.Product;
+            this.decompiler.TreatProductAsModule = true;
+            Wix.Wix wix = this.decompiler.Decompile(wixout);
+
+            if (null == wix)
+            {
+                return wix;
+            }
+
+            ConvertModule(wix);
+
+            return wix;
+        }
+
+        /// <summary>
+        /// Converts a Module to a ComponentGroup and adds all of its relevant elements to the main fragment.
+        /// </summary>
+        /// <param name="wix">The output object representing an unbound merge module.</param>
+        private void ConvertModule(Wix.Wix wix)
+        {
+            Wix.Product product = Melter.GetProduct(wix);
+
+            List<string> customActionsRemoved = new List<string>();
+            Dictionary<Wix.Custom, Wix.InstallExecuteSequence> customsToRemove = new Dictionary<Wix.Custom, Wix.InstallExecuteSequence>();
+
+            foreach (Wix.ISchemaElement child in product.Children)
+            {
+                Wix.Directory childDir = child as Wix.Directory;
+                if (null != childDir)
+                {
+                    bool isTargetDir = this.WalkDirectory(childDir);
+                    if (isTargetDir)
+                    {
+                        continue;
+                    }
+                }
+                else
+                {
+                    Wix.Dependency childDep = child as Wix.Dependency;
+                    if (null != childDep)
+                    {
+                        this.AddPropertyRef(childDep.RequiredId);
+                        continue;
+                    }
+                    else if (child is Wix.Package)
+                    {
+                        continue;
+                    }
+                    else if (child is Wix.CustomAction)
+                    {
+                        Wix.CustomAction customAction = child as Wix.CustomAction;
+                        string directoryId;
+                        if (StartsWithStandardDirectoryId(customAction.Id, out directoryId) && customAction.Property == customAction.Id)
+                        {
+                            customActionsRemoved.Add(customAction.Id);
+                            continue;
+                        }
+                    }
+                    else if (child is Wix.InstallExecuteSequence)
+                    {
+                        Wix.InstallExecuteSequence installExecuteSequence = child as Wix.InstallExecuteSequence;
+
+                        foreach (Wix.ISchemaElement sequenceChild in installExecuteSequence.Children)
+                        {
+                            Wix.Custom custom = sequenceChild as Wix.Custom;
+                            string directoryId;
+                            if (custom != null && StartsWithStandardDirectoryId(custom.Action, out directoryId))
+                            {
+                                customsToRemove.Add(custom, installExecuteSequence);
+                            }
+                        }
+                    }
+                }
+
+                this.fragment.AddChild(child);
+            }
+
+            // For any customaction that we removed, also remove the scheduling of that action.
+            foreach (Wix.Custom custom in customsToRemove.Keys)
+            {
+                if (customActionsRemoved.Contains(custom.Action))
+                {
+                    ((Wix.InstallExecuteSequence)customsToRemove[custom]).RemoveChild(custom);
+                }
+            }
+
+            AddProperty(this.moduleId, this.id);
+
+            wix.RemoveChild(product);
+            wix.AddChild(this.fragment);
+
+            this.fragment.AddChild(this.componentGroup);
+            this.fragment.AddChild(this.primaryDirectoryRef);
+        }
+
+        /// <summary>
+        /// Gets the module from the Wix object.
+        /// </summary>
+        /// <param name="wix">The Wix object.</param>
+        /// <returns>The Module in the Wix object, null if no Module was found</returns>
+        private static Wix.Product GetProduct(Wix.Wix wix)
+        {
+            foreach (Wix.ISchemaElement element in wix.Children)
+            {
+                Wix.Product productElement = element as Wix.Product;
+                if (null != productElement)
+                {
+                    return productElement;
+                }
+            }
+            return null;
+        }
+
+        /// <summary>
+        /// Adds a PropertyRef to the main Fragment.
+        /// </summary>
+        /// <param name="propertyRefId">Id of the PropertyRef.</param>
+        private void AddPropertyRef(string propertyRefId)
+        {
+            Wix.PropertyRef propertyRef = new Wix.PropertyRef();
+            propertyRef.Id = propertyRefId;
+            this.fragment.AddChild(propertyRef);
+        }
+
+        /// <summary>
+        /// Adds a Property to the main Fragment.
+        /// </summary>
+        /// <param name="propertyId">Id of the Property.</param>
+        /// <param name="value">Value of the Property.</param>
+        private void AddProperty(string propertyId, string value)
+        {
+            Wix.Property property = new Wix.Property();
+            property.Id = propertyId;
+            property.Value = value;
+            this.fragment.AddChild(property);
+        }
+
+        /// <summary>
+        /// Walks a directory structure obtaining Component Id's and Standard Directory Id's.
+        /// </summary>
+        /// <param name="directory">The Directory to walk.</param>
+        /// <returns>true if the directory is TARGETDIR.</returns>
+        private bool WalkDirectory(Wix.Directory directory)
+        {
+            bool isTargetDir = false;
+            if ("TARGETDIR" == directory.Id)
+            {
+                isTargetDir = true;
+            }
+
+            string standardDirectoryId = null;
+            if (Melter.StartsWithStandardDirectoryId(directory.Id, out standardDirectoryId) && !isTargetDir)
+            {
+                this.AddSetPropertyCustomAction(directory.Id, String.Format(CultureInfo.InvariantCulture, "[{0}]", standardDirectoryId));
+            }
+
+            foreach (Wix.ISchemaElement child in directory.Children)
+            {
+                Wix.Directory childDir = child as Wix.Directory;
+                if (null != childDir)
+                {
+                    if (isTargetDir)
+                    {
+                        this.primaryDirectoryRef.AddChild(child);
+                    }
+                    this.WalkDirectory(childDir);
+                }
+                else
+                {
+                    Wix.Component childComponent = child as Wix.Component;
+                    if (null != childComponent)
+                    {
+                        if (isTargetDir)
+                        {
+                            this.primaryDirectoryRef.AddChild(child);
+                        }
+                        this.AddComponentRef(childComponent);
+                    }
+                }
+            }
+
+            return isTargetDir;
+        }
+
+        /// <summary>
+        /// Gets the module Id out of the Output object.
+        /// </summary>
+        /// <param name="wixout">The output object.</param>
+        /// <returns>The module Id from the Output object.</returns>
+        private string GetModuleId(Output wixout)
+        {
+            // get the moduleId from the wixout
+            Table moduleSignatureTable = wixout.Tables["ModuleSignature"];
+            if (null == moduleSignatureTable || 0 >= moduleSignatureTable.Rows.Count)
+            {
+                this.core.OnMessage(WixErrors.ExpectedTableInMergeModule("ModuleSignature"));
+            }
+            return moduleSignatureTable.Rows[0].Fields[0].Data.ToString();
+        }
+
+        /// <summary>
+        /// Determines if the directory Id starts with a standard directory id.
+        /// </summary>
+        /// <param name="directoryId">The directory id.</param>
+        /// <param name="standardDirectoryId">The standard directory id.</param>
+        /// <returns>true if the directory starts with a standard directory id.</returns>
+        private static bool StartsWithStandardDirectoryId(string directoryId, out string standardDirectoryId)
+        {
+            standardDirectoryId = null;
+            foreach (string id in WindowsInstallerStandard.GetStandardDirectories())
+            {
+                if (directoryId.StartsWith(id, StringComparison.Ordinal))
+                {
+                    standardDirectoryId = id;
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Adds a ComponentRef to the main ComponentGroup.
+        /// </summary>
+        /// <param name="component">The component to add.</param>
+        private void AddComponentRef(Wix.Component component)
+        {
+            Wix.ComponentRef componentRef = new Wix.ComponentRef();
+            componentRef.Id = component.Id;
+            this.componentGroup.AddChild(componentRef);
+        }
+
+        /// <summary>
+        /// Adds a SetProperty CA for a Directory.
+        /// </summary>
+        /// <param name="propertyId">The Id of the Property to set.</param>
+        /// <param name="value">The value to set the Property to.</param>
+        private void AddSetPropertyCustomAction(string propertyId, string value)
+        {
+            // Add the action
+            Wix.CustomAction customAction = new Wix.CustomAction();
+            customAction.Id = propertyId;
+            customAction.Property = propertyId;
+            customAction.Value = value;
+            this.fragment.AddChild(customAction);
+
+            // Schedule the action
+            Wix.InstallExecuteSequence installExecuteSequence = new Wix.InstallExecuteSequence();
+            Wix.Custom custom = new Wix.Custom();
+            custom.Action = customAction.Id;
+            custom.Before = "CostInitialize";
+            installExecuteSequence.AddChild(custom);
+            this.fragment.AddChild(installExecuteSequence);
+        }
+
+        /// <summary>
+        /// Does any operations to the wixout that would need to be done before decompiling.
+        /// </summary>
+        /// <param name="wixout">The output object representing the unbound merge module.</param>
+        private void PreDecompile(Output wixout)
+        {
+            string wixVariable = String.Format(CultureInfo.InvariantCulture, "!(wix.{0}", this.id);
+
+            foreach (Table table in wixout.Tables)
+            {
+                // Determine if the table has a feature foreign key
+                bool hasFeatureForeignKey = false;
+                foreach (ColumnDefinition columnDef in table.Definition.Columns)
+                {
+                    if (null != columnDef.KeyTable)
+                    {
+                        string[] keyTables = columnDef.KeyTable.Split(';');
+                        foreach (string keyTable in keyTables)
+                        {
+                            if ("Feature" == keyTable)
+                            {
+                                hasFeatureForeignKey = true;
+                                break;
+                            }
+                        }
+                    }
+                }
+
+                // If this table has no foreign keys to the feature table, skip it.
+                if (!hasFeatureForeignKey)
+                {
+                    continue;
+                }
+
+                // Go through all the rows and replace the null guid with the wix variable
+                // for columns that are foreign keys into the feature table.
+                foreach (Row row in table.Rows)
+                {
+                    foreach (Field field in row.Fields)
+                    {
+                        if (null != field.Column.KeyTable)
+                        {
+                            string[] keyTables = field.Column.KeyTable.Split(';');
+                            foreach (string keyTable in keyTables)
+                            {
+                                if ("Feature" == keyTable)
+                                {
+                                    field.Data = field.Data.ToString().Replace(nullGuid, wixVariable);
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/MelterCore.cs b/src/WixToolset.Core/MelterCore.cs
new file mode 100644
index 00000000..75d43619
--- /dev/null
+++ b/src/WixToolset.Core/MelterCore.cs
@@ -0,0 +1,30 @@
+// 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
+{
+    using WixToolset.Data;
+
+    /// <summary>
+    /// Melts a Module Wix document into a ComponentGroup representation.
+    /// </summary>
+    public sealed class MelterCore : IMessageHandler
+    {
+        /// <summary>
+        /// Gets whether the melter core encountered an error while processing.
+        /// </summary>
+        /// <value>Flag if core encountered an error during processing.</value>
+        public bool EncounteredError
+        {
+            get { return Messaging.Instance.EncounteredError; }
+        }
+
+        /// <summary>
+        /// Sends a message to the message delegate if there is one.
+        /// </summary>
+        /// <param name="mea">Message event arguments.</param>
+        public void OnMessage(MessageEventArgs e)
+        {
+            Messaging.Instance.OnMessage(e);
+        }
+    }
+}
diff --git a/src/WixToolset.Core/MergeMod/NativeMethods.cs b/src/WixToolset.Core/MergeMod/NativeMethods.cs
new file mode 100644
index 00000000..daf259b4
--- /dev/null
+++ b/src/WixToolset.Core/MergeMod/NativeMethods.cs
@@ -0,0 +1,508 @@
+// 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.
+#if false
+namespace WixToolset.MergeMod
+{
+    using System;
+    using System.Collections;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    /// <summary>
+    /// Errors returned by merge operations.
+    /// </summary>
+    [Guid("0ADDA825-2C26-11D2-AD65-00A0C9AF11A6")]
+    internal enum MsmErrorType
+    {
+        /// <summary>
+        /// A request was made to open a module with a language not supported by the module.
+        /// No more general language is supported by the module.
+        /// Adds msmErrorLanguageUnsupported to the Type property and the requested language
+        /// to the Language Property (Error Object).  All Error object properties are empty.
+        /// The OpenModule function returns ERROR_INSTALL_LANGUAGE_UNSUPPORTED (as HRESULT).
+        /// </summary>
+        msmErrorLanguageUnsupported = 1,
+
+        /// <summary>
+        /// A request was made to open a module with a supported language but the module has
+        /// an invalid language transform.  Adds msmErrorLanguageFailed to the Type property
+        /// and the applied transform's language to the Language Property of the Error object.
+        /// This may not be the requested language if a more general language was used.
+        /// All other properties of the Error object are empty.  The OpenModule function
+        /// returns ERROR_INSTALL_LANGUAGE_UNSUPPORTED (as HRESULT).
+        /// </summary>
+        msmErrorLanguageFailed = 2,
+
+        /// <summary>
+        /// The module cannot be merged because it excludes, or is excluded by, another module
+        /// in the database.  Adds msmErrorExclusion to the Type property of the Error object.
+        /// The ModuleKeys property or DatabaseKeys property contains the primary keys of the
+        /// excluded module's row in the ModuleExclusion table.  If an existing module excludes
+        /// the module being merged, the excluded module's ModuleSignature information is added
+        /// to ModuleKeys.  If the module being merged excludes an existing module, DatabaseKeys
+        /// contains the excluded module's ModuleSignature information.  All other properties
+        /// are empty (or -1).
+        /// </summary>
+        msmErrorExclusion = 3,
+
+        /// <summary>
+        /// Merge conflict during merge.  The value of the Type property is set to
+        /// msmErrorTableMerge.  The DatabaseTable property and DatabaseKeys property contain
+        /// the table name and primary keys of the conflicting row in the database.  The
+        /// ModuleTable property and ModuleKeys property contain the table name and primary keys
+        /// of the conflicting row in the module.  The ModuleTable and ModuleKeys entries may be
+        /// null if the row does not exist in the database.  For example, if the conflict is in a
+        /// generated FeatureComponents table entry.  On Windows Installer version 2.0, when
+        /// merging a configurable merge module, configuration may cause these properties to
+        /// refer to rows that do not exist in the module.
+        /// </summary>
+        msmErrorTableMerge = 4,
+
+        /// <summary>
+        /// There was a problem resequencing a sequence table to contain the necessary merged
+        /// actions.  The Type property is set to msmErrorResequenceMerge. The DatabaseTable
+        /// and DatabaseKeys properties contain the sequence table name and primary keys
+        /// (action name) of the conflicting row.  The ModuleTable and ModuleKeys properties
+        /// contain the sequence table name and primary key (action name) of the conflicting row.
+        /// On Windows Installer version 2.0, when merging a configurable merge module,
+        /// configuration may cause these properties to refer to rows that do not exist in the module.
+        /// </summary>
+        msmErrorResequenceMerge = 5,
+
+        /// <summary>
+        /// Not used.
+        /// </summary>
+        msmErrorFileCreate = 6,
+
+        /// <summary>
+        /// There was a problem creating a directory to extract a file to disk.  The Path property
+        /// contains the directory that could not be created.  All other properties are empty or -1.
+        /// Not available with Windows Installer version 1.0.
+        /// </summary>
+        msmErrorDirCreate = 7,
+
+        /// <summary>
+        /// A feature name is required to complete the merge, but no feature name was provided.
+        /// The Type property is set to msmErrorFeatureRequired.  The DatabaseTable and DatabaseKeys
+        /// contain the table name and primary keys of the conflicting row.  The ModuleTable and
+        /// ModuleKeys properties contain the table name and primary keys of the row cannot be merged.
+        /// On Windows Installer version 2.0, when merging a configurable merge module, configuration
+        /// may cause these properties to refer to rows that do not exist in the module.
+        /// If the failure is in a generated FeatureComponents table, the DatabaseTable and
+        /// DatabaseKeys properties are empty and the ModuleTable and ModuleKeys properties refer to
+        /// the row in the Component table causing the failure.
+        /// </summary>
+        msmErrorFeatureRequired = 8,
+
+        /// <summary>
+        /// Available with Window Installer version 2.0. Substitution of a Null value into a
+        /// non-nullable column.  This enters msmErrorBadNullSubstitution in the Type property and
+        /// enters "ModuleSubstitution" and the keys from the ModuleSubstitution table for this row
+        /// into the ModuleTable property and ModuleKeys property.  All other properties of the Error
+        /// object are set to an empty string or -1.  This error causes the immediate failure of the
+        /// merge and the MergeEx function to return E_FAIL.
+        /// </summary>
+        msmErrorBadNullSubstitution = 9,
+
+        /// <summary>
+        /// Available with Window Installer version 2.0.  Substitution of Text Format Type or Integer
+        /// Format Type into a Binary Type data column.  This type of error returns
+        /// msmErrorBadSubstitutionType in the Type property and enters "ModuleSubstitution" and the
+        /// keys from the ModuleSubstitution table for this row into the ModuleTable property.
+        /// All other properties of the Error object are set to an empty string or -1.  This error
+        /// causes the immediate failure of the merge and the MergeEx function to return E_FAIL.
+        /// </summary>
+        msmErrorBadSubstitutionType = 10,
+
+        /// <summary>
+        /// Available with Window Installer Version 2.0.  A row in the ModuleSubstitution table
+        /// references a configuration item not defined in the ModuleConfiguration table.
+        /// This type of error returns msmErrorMissingConfigItem in the Type property and enters
+        /// "ModuleSubstitution" and the keys from the ModuleSubstitution table for this row into
+        /// the ModuleTable property. All other properties of the Error object are set to an empty
+        /// string or -1.  This error causes the immediate failure of the merge and the MergeEx
+        /// function to return E_FAIL.
+        /// </summary>
+        msmErrorMissingConfigItem = 11,
+
+        /// <summary>
+        /// Available with Window Installer version 2.0.  The authoring tool has returned a Null
+        /// value for an item marked with the msmConfigItemNonNullable attribute.  An error of this
+        /// type returns msmErrorBadNullResponse in the Type property and enters "ModuleSubstitution"
+        /// and the keys from the ModuleSubstitution table for for the item into the ModuleTable property.
+        /// All other properties of the Error object are set to an empty string or -1.  This error
+        /// causes the immediate failure of the merge and the MergeEx function to return E_FAIL.
+        /// </summary>
+        msmErrorBadNullResponse = 12,
+
+        /// <summary>
+        /// Available with Window Installer version 2.0.  The authoring tool returned a failure code
+        /// (not S_OK or S_FALSE) when asked for data. An error of this type will return
+        /// msmErrorDataRequestFailed in the Type property and enters "ModuleSubstitution"
+        /// and the keys from the ModuleSubstitution table for the item into the ModuleTable property.
+        /// All other properties of the Error object are set to an empty string or -1.  This error
+        /// causes the immediate failure of the merge and the MergeEx function to return E_FAIL.
+        /// </summary>
+        msmErrorDataRequestFailed = 13,
+
+        /// <summary>
+        /// Available with Windows Installer 2.0 and later versions.  Indicates that an attempt was
+        /// made to merge a 64-bit module into a package that was not a 64-bit package.  An error of
+        /// this type returns msmErrorPlatformMismatch in the Type property.  All other properties of
+        /// the error object are set to an empty string or -1. This error causes the immediate failure
+        /// of the merge and causes the Merge function or MergeEx function to return E_FAIL.
+        /// </summary>
+        msmErrorPlatformMismatch = 14,
+    }
+
+    /// <summary>
+    /// IMsmMerge2 interface.
+    /// </summary>
+    [ComImport, Guid("351A72AB-21CB-47ab-B7AA-C4D7B02EA305")]
+    internal interface IMsmMerge2
+    {
+        /// <summary>
+        /// The OpenDatabase method of the Merge object opens a Windows Installer installation
+        /// database, located at a specified path, that is to be merged with a module.
+        /// </summary>
+        /// <param name="path">Path to the database being opened.</param>
+        void OpenDatabase(string path);
+
+        /// <summary>
+        /// The OpenModule method of the Merge object opens a Windows Installer merge module
+        /// in read-only mode. A module must be opened before it can be merged with an installation database.
+        /// </summary>
+        /// <param name="fileName">Fully qualified file name pointing to a merge module.</param>
+        /// <param name="language">A valid language identifier (LANGID).</param>
+        void OpenModule(string fileName, short language);
+
+        /// <summary>
+        /// The CloseDatabase method of the Merge object closes the currently open Windows Installer database.
+        /// </summary>
+        /// <param name="commit">true if changes should be saved, false otherwise.</param>
+        void CloseDatabase(bool commit);
+
+        /// <summary>
+        /// The CloseModule method of the Merge object closes the currently open Windows Installer merge module.
+        /// </summary>
+        void CloseModule();
+
+        /// <summary>
+        /// The OpenLog method of the Merge object opens a log file that receives progress and error messages.
+        /// If the log file already exists, the installer appends new messages. If the log file does not exist,
+        /// the installer creates a log file.
+        /// </summary>
+        /// <param name="fileName">Fully qualified filename pointing to a file to open or create.</param>
+        void OpenLog(string fileName);
+
+        /// <summary>
+        /// The CloseLog method of the Merge object closes the current log file.
+        /// </summary>
+        void CloseLog();
+
+        /// <summary>
+        /// The Log method of the Merge object writes a text string to the currently open log file.
+        /// </summary>
+        /// <param name="message">The text string to display.</param>
+        void Log(string message);
+
+        /// <summary>
+        /// Gets the errors from the last merge operation.
+        /// </summary>
+        /// <value>The errors from the last merge operation.</value>
+        IMsmErrors Errors
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Gets a collection of Dependency objects that enumerates a set of unsatisfied dependencies for the current database.
+        /// </summary>
+        /// <value>A  collection of Dependency objects that enumerates a set of unsatisfied dependencies for the current database.</value>
+        object Dependencies
+        {
+            get;
+        }
+
+        /// <summary>
+        /// The Merge method of the Merge object executes a merge of the current database and current
+        /// module. The merge attaches the components in the module to the feature identified by Feature.
+        /// The root of the module's directory tree is redirected to the location given by RedirectDir.
+        /// </summary>
+        /// <param name="feature">The name of a feature in the database.</param>
+        /// <param name="redirectDir">The key of an entry in the Directory table of the database.
+        /// This parameter may be NULL or an empty string.</param>
+        void Merge(string feature, string redirectDir);
+
+        /// <summary>
+        /// The Connect method of the Merge object connects a module to an additional feature.
+        /// The module must have already been merged into the database or will be merged into the database.
+        /// The feature must exist before calling this function.
+        /// </summary>
+        /// <param name="feature">The name of a feature already existing in the database.</param>
+        void Connect(string feature);
+
+        /// <summary>
+        /// The ExtractCAB method of the Merge object extracts the embedded .cab file from a module and
+        /// saves it as the specified file. The installer creates this file if it does not already exist
+        /// and overwritten if it does exist.
+        /// </summary>
+        /// <param name="fileName">The fully qualified destination file.</param>
+        void ExtractCAB(string fileName);
+
+        /// <summary>
+        /// The ExtractFiles method of the Merge object extracts the embedded .cab file from a module
+        /// and then writes those files to the destination directory.
+        /// </summary>
+        /// <param name="path">The fully qualified destination directory.</param>
+        void ExtractFiles(string path);
+
+        /// <summary>
+        /// The MergeEx method of the Merge object is equivalent to the Merge function, except that it
+        /// takes an extra argument.  The Merge method executes a merge of the current database and
+        /// current module. The merge attaches the components in the module to the feature identified
+        /// by Feature. The root of the module's directory tree is redirected to the location given by RedirectDir.
+        /// </summary>
+        /// <param name="feature">The name of a feature in the database.</param>
+        /// <param name="redirectDir">The key of an entry in the Directory table of the database. This parameter may
+        /// be NULL or an empty string.</param>
+        /// <param name="configuration">The pConfiguration argument is an interface implemented by the client. The argument may
+        /// be NULL. The presence of this argument indicates that the client is capable of supporting the configuration
+        /// functionality, but does not obligate the client to provide configuration data for any specific configurable item.</param>
+        void MergeEx(string feature, string redirectDir, IMsmConfigureModule configuration);
+
+        /// <summary>
+        /// The ExtractFilesEx method of the Merge object extracts the embedded .cab file from a module and
+        /// then writes those files to the destination directory.
+        /// </summary>
+        /// <param name="path">The fully qualified destination directory.</param>
+        /// <param name="longFileNames">Set to specify using long file names for path segments and final file names.</param>
+        /// <param name="filePaths">This is a list of fully-qualified paths for the files that were successfully extracted.
+        /// The list is empty if no files can be extracted.  This argument may be null.  No list is provided if pFilePaths is null.</param>
+        void ExtractFilesEx(string path, bool longFileNames, ref IntPtr filePaths);
+
+        /// <summary>
+        /// Gets a collection ConfigurableItem objects, each of which represents a single row from the ModuleConfiguration table.
+        /// </summary>
+        /// <value>A collection ConfigurableItem objects, each of which represents a single row from the ModuleConfiguration table.</value>
+        /// <remarks>Semantically, each interface in the enumerator represents an item that can be configured by the module consumer.
+        /// The collection is a read-only collection and implements the standard read-only collection interfaces of Item(), Count() and _NewEnum().
+        /// The IEnumMsmConfigItems enumerator implements Next(), Skip(), Reset(), and Clone() with the standard semantics.</remarks>
+        object ConfigurableItems
+        {
+            get;
+        }
+
+        /// <summary>
+        /// The CreateSourceImage method of the Merge object allows the client to extract the files from a module to
+        /// a source image on disk after a merge, taking into account changes to the module that might have been made
+        /// during module configuration. The list of files to be extracted is taken from the file table of the module
+        /// during the merge process. The list of files consists of every file successfully copied from the file table
+        /// of the module to the target database. File table entries that were not copied due to primary key conflicts
+        /// with existing rows in the database are not a part of this list. At image creation time, the directory for
+        /// each of these files comes from the open (post-merge) database. The path specified in the Path parameter is
+        /// the root of the source image for the install. fLongFileNames determines whether or not long file names are
+        /// used for both path segments and final file names. The function fails if no database is open, no module is
+        /// open, or no merge has been performed.
+        /// </summary>
+        /// <param name="path">The path of the root of the source image for the install.</param>
+        /// <param name="longFileNames">Determines whether or not long file names are used for both path segments and final file names. </param>
+        /// <param name="filePaths">This is a list of fully-qualified paths for the files that were successfully extracted.
+        /// The list is empty if no files can be extracted.  This argument may be null.  No list is provided if pFilePaths is null.</param>
+        void CreateSourceImage(string path, bool longFileNames, ref IntPtr filePaths);
+
+        /// <summary>
+        /// The get_ModuleFiles function implements the ModuleFiles property of the GetFiles object. This function
+        /// returns the primary keys in the File table of the currently open module. The primary keys are returned
+        /// as a collection of strings. The module must be opened by a call to the OpenModule function before calling get_ModuleFiles.
+        /// </summary>
+        IMsmStrings ModuleFiles
+        {
+            get;
+        }
+    }
+
+    /// <summary>
+    /// Collection of merge errors.
+    /// </summary>
+    [ComImport, Guid("0ADDA82A-2C26-11D2-AD65-00A0C9AF11A6")]
+    internal interface IMsmErrors
+    {
+        /// <summary>
+        /// Gets the IMsmError at the specified index.
+        /// </summary>
+        /// <param name="index">The one-based index of the IMsmError to get.</param>
+        IMsmError this[int index]
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Gets the count of IMsmErrors in this collection.
+        /// </summary>
+        /// <value>The count of IMsmErrors in this collection.</value>
+        int Count
+        {
+            get;
+        }
+    }
+
+    /// <summary>
+    /// A merge error.
+    /// </summary>
+    [ComImport, Guid("0ADDA828-2C26-11D2-AD65-00A0C9AF11A6")]
+    internal interface IMsmError
+    {
+        /// <summary>
+        /// Gets the type of merge error.
+        /// </summary>
+        /// <value>The type of merge error.</value>
+        MsmErrorType Type
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Gets the path information from the merge error.
+        /// </summary>
+        /// <value>The path information from the merge error.</value>
+        string Path
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Gets the language information from the merge error.
+        /// </summary>
+        /// <value>The language information from the merge error.</value>
+        short Language
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Gets the database table from the merge error.
+        /// </summary>
+        /// <value>The database table from the merge error.</value>
+        string DatabaseTable
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Gets the collection of database keys from the merge error.
+        /// </summary>
+        /// <value>The collection of database keys from the merge error.</value>
+        IMsmStrings DatabaseKeys
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Gets the module table from the merge error.
+        /// </summary>
+        /// <value>The module table from the merge error.</value>
+        string ModuleTable
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Gets the collection of module keys from the merge error.
+        /// </summary>
+        /// <value>The collection of module keys from the merge error.</value>
+        IMsmStrings ModuleKeys
+        {
+            get;
+        }
+    }
+
+    /// <summary>
+    /// A collection of strings.
+    /// </summary>
+    [ComImport, Guid("0ADDA827-2C26-11D2-AD65-00A0C9AF11A6")]
+    internal interface IMsmStrings
+    {
+        /// <summary>
+        /// Gets the string at the specified index.
+        /// </summary>
+        /// <param name="index">The one-based index of the string to get.</param>
+        string this[int index]
+        {
+            get;
+        }
+
+        /// <summary>
+        /// Gets the count of strings in this collection.
+        /// </summary>
+        /// <value>The count of strings in this collection.</value>
+        int Count
+        {
+            get;
+        }
+    }
+
+    /// <summary>
+    /// Callback for configurable merge modules.
+    /// </summary>
+    [ComImport, Guid("AC013209-18A7-4851-8A21-2353443D70A0"), InterfaceType(ComInterfaceType.InterfaceIsIDispatch)]
+    internal interface IMsmConfigureModule
+    {
+        /// <summary>
+        /// Callback to retrieve text data for configurable merge modules.
+        /// </summary>
+        /// <param name="name">Name of the data to be retrieved.</param>
+        /// <param name="configData">The data corresponding to the name.</param>
+        /// <returns>The error code (HRESULT).</returns>
+        [PreserveSig]
+        int ProvideTextData([In, MarshalAs(UnmanagedType.BStr)] string name, [MarshalAs(UnmanagedType.BStr)] out string configData);
+
+        /// <summary>
+        /// Callback to retrieve integer data for configurable merge modules.
+        /// </summary>
+        /// <param name="name">Name of the data to be retrieved.</param>
+        /// <param name="configData">The data corresponding to the name.</param>
+        /// <returns>The error code (HRESULT).</returns>
+        [PreserveSig]
+        int ProvideIntegerData([In, MarshalAs(UnmanagedType.BStr)] string name, out int configData);
+    }
+
+    /// <summary>
+    /// Merge merge modules into an MSI file.
+    /// </summary>
+    [ComImport, Guid("F94985D5-29F9-4743-9805-99BC3F35B678")]
+    internal class MsmMerge2
+    {
+    }
+
+    /// <summary>
+    /// Defines the standard COM IClassFactory interface.
+    /// </summary>
+    [ComImport, Guid("00000001-0000-0000-C000-000000000046")]
+    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+    internal interface IClassFactory
+    {
+        [return:MarshalAs(UnmanagedType.IUnknown)]
+        object CreateInstance(IntPtr unkOuter, [MarshalAs(UnmanagedType.LPStruct)] Guid iid);
+    }
+
+    /// <summary>
+    /// Contains native methods for merge operations.
+    /// </summary>
+    internal class NativeMethods
+    {
+        [DllImport("mergemod.dll", EntryPoint="DllGetClassObject", PreserveSig=false)]
+        [return: MarshalAs(UnmanagedType.IUnknown)]
+        private static extern object MergeModGetClassObject([MarshalAs(UnmanagedType.LPStruct)] Guid clsid, [MarshalAs(UnmanagedType.LPStruct)] Guid iid);
+
+        /// <summary>
+        /// Load the merge object directly from a local mergemod.dll without going through COM registration.
+        /// </summary>
+        /// <returns>Merge interface.</returns>
+        internal static IMsmMerge2 GetMsmMerge()
+        {
+            IClassFactory classFactory = (IClassFactory) MergeModGetClassObject(typeof(MsmMerge2).GUID, typeof(IClassFactory).GUID);
+            return (IMsmMerge2) classFactory.CreateInstance(IntPtr.Zero, typeof(IMsmMerge2).GUID);
+        }
+    }
+}
+#endif
\ No newline at end of file
diff --git a/src/WixToolset.Core/Msi/Database.cs b/src/WixToolset.Core/Msi/Database.cs
new file mode 100644
index 00000000..7c3a97bb
--- /dev/null
+++ b/src/WixToolset.Core/Msi/Database.cs
@@ -0,0 +1,303 @@
+// 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.Msi
+{
+    using System;
+    using System.ComponentModel;
+    using System.Globalization;
+    using System.IO;
+    using System.Text;
+    using System.Threading;
+    using WixToolset.Data;
+    using WixToolset.Core.Native;
+
+    /// <summary>
+    /// Wrapper class for managing MSI API database handles.
+    /// </summary>
+    internal sealed class Database : MsiHandle
+    {
+        private const int STG_E_LOCKVIOLATION = unchecked((int)0x80030021);
+
+        /// <summary>
+        /// Constructor that opens an MSI database.
+        /// </summary>
+        /// <param name="path">Path to the database to be opened.</param>
+        /// <param name="type">Persist mode to use when opening the database.</param>
+        public Database(string path, OpenDatabase type)
+        {
+            uint handle = 0;
+            int error = MsiInterop.MsiOpenDatabase(path, new IntPtr((int)type), out handle);
+            if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+            this.Handle = handle;
+        }
+
+        public void ApplyTransform(string transformFile)
+        {
+            // get the curret validation bits
+            TransformErrorConditions conditions = TransformErrorConditions.None;
+            using (SummaryInformation summaryInfo = new SummaryInformation(transformFile))
+            {
+                string value = summaryInfo.GetProperty((int)SummaryInformation.Transform.ValidationFlags);
+                try
+                {
+                    int validationFlags = Int32.Parse(value, CultureInfo.InvariantCulture);
+                    conditions = (TransformErrorConditions)(validationFlags & 0xffff);
+                }
+                catch (FormatException)
+                {
+                    // fallback to default of None
+                }
+            }
+
+            this.ApplyTransform(transformFile, conditions);
+        }
+
+        /// <summary>
+        /// Applies a transform to this database.
+        /// </summary>
+        /// <param name="transformFile">Path to the transform file being applied.</param>
+        /// <param name="errorConditions">Specifies the error conditions that are to be suppressed.</param>
+        public void ApplyTransform(string transformFile, TransformErrorConditions errorConditions)
+        {
+            int error = MsiInterop.MsiDatabaseApplyTransform(this.Handle, transformFile, errorConditions);
+            if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+        }
+
+        /// <summary>
+        /// Commits changes made to the database.
+        /// </summary>
+        public void Commit()
+        {
+            // Retry this call 3 times to deal with an MSI internal locking problem.
+            const int retryWait = 300;
+            const int retryLimit = 3;
+            int error = 0;
+
+            for (int i = 1; i <= retryLimit; ++i)
+            {
+                error = MsiInterop.MsiDatabaseCommit(this.Handle);
+
+                if (0 == error)
+                {
+                    return;
+                }
+                else
+                {
+                    MsiException exception = new MsiException(error);
+
+                    // We need to see if the error code is contained in any of the strings in ErrorInfo.
+                    // Join the array together and search for the error code to cover the string array.
+                    if (!String.Join(", ", exception.ErrorInfo).Contains(STG_E_LOCKVIOLATION.ToString()))
+                    {
+                        break;
+                    }
+
+                    Console.Error.WriteLine(String.Format("Failed to create the database. Info: {0}. Retrying ({1} of {2})", String.Join(", ", exception.ErrorInfo), i, retryLimit));
+                    Thread.Sleep(retryWait);
+                }
+            }
+
+            throw new MsiException(error);
+        }
+
+        /// <summary>
+        /// Creates and populates the summary information stream of an existing transform file.
+        /// </summary>
+        /// <param name="referenceDatabase">Required database that does not include the changes.</param>
+        /// <param name="transformFile">The name of the generated transform file.</param>
+        /// <param name="errorConditions">Required error conditions that should be suppressed when the transform is applied.</param>
+        /// <param name="validations">Required when the transform is applied to a database;
+        /// shows which properties should be validated to verify that this transform can be applied to the database.</param>
+        public void CreateTransformSummaryInfo(Database referenceDatabase, string transformFile, TransformErrorConditions errorConditions, TransformValidations validations)
+        {
+            int error = MsiInterop.MsiCreateTransformSummaryInfo(this.Handle, referenceDatabase.Handle, transformFile, errorConditions, validations);
+            if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+        }
+
+        /// <summary>
+        /// Imports an installer text archive table (idt file) into an open database.
+        /// </summary>
+        /// <param name="idtPath">Specifies the path to the file to import.</param>
+        /// <exception cref="WixInvalidIdtException">Attempted to import an IDT file with an invalid format or unsupported data.</exception>
+        /// <exception cref="MsiException">Another error occured while importing the IDT file.</exception>
+        public void Import(string idtPath)
+        {
+            string folderPath = Path.GetDirectoryName(idtPath);
+            string fileName = Path.GetFileName(idtPath);
+
+            int error = MsiInterop.MsiDatabaseImport(this.Handle, folderPath, fileName);
+            if (1627 == error) // ERROR_FUNCTION_FAILED
+            {
+                throw new WixInvalidIdtException(idtPath);
+            }
+            else if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+        }
+
+        /// <summary>
+        /// Exports an installer table from an open database to a text archive file (idt file).
+        /// </summary>
+        /// <param name="tableName">Specifies the name of the table to export.</param>
+        /// <param name="folderPath">Specifies the name of the folder that contains archive files. If null or empty string, uses current directory.</param>
+        /// <param name="fileName">Specifies the name of the exported table archive file.</param>
+        public void Export(string tableName, string folderPath, string fileName)
+        {
+            if (null == folderPath || 0 == folderPath.Length)
+            {
+                folderPath = System.Environment.CurrentDirectory;
+            }
+
+            int error = MsiInterop.MsiDatabaseExport(this.Handle, tableName, folderPath, fileName);
+            if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+        }
+
+        /// <summary>
+        /// Creates a transform that, when applied to the reference database, results in this database.
+        /// </summary>
+        /// <param name="referenceDatabase">Required database that does not include the changes.</param>
+        /// <param name="transformFile">The name of the generated transform file. This is optional.</param>
+        /// <returns>true if a transform is generated; false if a transform is not generated because
+        /// there are no differences between the two databases.</returns>
+        public bool GenerateTransform(Database referenceDatabase, string transformFile)
+        {
+            int error = MsiInterop.MsiDatabaseGenerateTransform(this.Handle, referenceDatabase.Handle, transformFile, 0, 0);
+            if (0 != error && 0xE8 != error) // ERROR_NO_DATA(0xE8) means no differences were found
+            {
+                throw new MsiException(error);
+            }
+
+            return (0xE8 != error);
+        }
+
+        /// <summary>
+        /// Merges two databases together.
+        /// </summary>
+        /// <param name="mergeDatabase">The database to merge into the base database.</param>
+        /// <param name="tableName">The name of the table to receive merge conflict information.</param>
+        public void Merge(Database mergeDatabase, string tableName)
+        {
+            int error = MsiInterop.MsiDatabaseMerge(this.Handle, mergeDatabase.Handle, tableName);
+            if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+        }
+
+        /// <summary>
+        /// Prepares a database query and creates a <see cref="View">View</see> object.
+        /// </summary>
+        /// <param name="query">Specifies a SQL query string for querying the database.</param>
+        /// <returns>A view object is returned if the query was successful.</returns>
+        public View OpenView(string query)
+        {
+            return new View(this, query);
+        }
+
+        /// <summary>
+        /// Prepares and executes a database query and creates a <see cref="View">View</see> object.
+        /// </summary>
+        /// <param name="query">Specifies a SQL query string for querying the database.</param>
+        /// <returns>A view object is returned if the query was successful.</returns>
+        public View OpenExecuteView(string query)
+        {
+            View view = new View(this, query);
+
+            view.Execute();
+            return view;
+        }
+
+        /// <summary>
+        /// Verifies the existence or absence of a table.
+        /// </summary>
+        /// <param name="tableName">Table name to to verify the existence of.</param>
+        /// <returns>Returns true if the table exists, false if it does not.</returns>
+        public bool TableExists(string tableName)
+        {
+            int result = MsiInterop.MsiDatabaseIsTablePersistent(this.Handle, tableName);
+            return MsiInterop.MSICONDITIONTRUE == result;
+        }
+
+        /// <summary>
+        /// Returns a <see cref="Record">Record</see> containing the names of all the primary 
+        /// key columns for a specified table.
+        /// </summary>
+        /// <param name="tableName">Specifies the name of the table from which to obtain 
+        /// primary key names.</param>
+        /// <returns>Returns a <see cref="Record">Record</see> containing the names of all the 
+        /// primary key columns for a specified table.</returns>
+        public Record PrimaryKeys(string tableName)
+        {
+            uint recordHandle;
+            int error = MsiInterop.MsiDatabaseGetPrimaryKeys(this.Handle, tableName, out recordHandle);
+            if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+
+            return new Record(recordHandle);
+        }
+
+        /// <summary>
+        /// Imports a table into the database.
+        /// </summary>
+        /// <param name="codepage">Codepage of the database to import table to.</param>
+        /// <param name="table">Table to import into database.</param>
+        /// <param name="baseDirectory">The base directory where intermediate files are created.</param>
+        /// <param name="keepAddedColumns">Whether to keep columns added in a transform.</param>
+        public void ImportTable(int codepage, Table table, string baseDirectory, bool keepAddedColumns)
+        {
+            // write out the table to an IDT file
+            string idtPath = Path.Combine(baseDirectory, String.Concat(table.Name, ".idt"));
+            Encoding encoding;
+
+            // If UTF8 encoding, use the UTF8-specific constructor to avoid writing
+            // the byte order mark at the beginning of the file
+            if (Encoding.UTF8.CodePage == codepage)
+            {
+                encoding = new UTF8Encoding(false, true);
+            }
+            else
+            {
+                if (0 == codepage)
+                {
+                    codepage = Encoding.ASCII.CodePage;
+                }
+
+                encoding = Encoding.GetEncoding(codepage, new EncoderExceptionFallback(), new DecoderExceptionFallback());
+            }
+
+            using (StreamWriter idtWriter = new StreamWriter(idtPath, false, encoding))
+            {
+                table.ToIdtDefinition(idtWriter, keepAddedColumns);
+            }
+
+            // try to import the table into the MSI
+            try
+            {
+                this.Import(idtPath);
+            }
+            catch (WixInvalidIdtException)
+            {
+                table.ValidateRows();
+
+                // If ValidateRows finds anything it doesn't like, it throws. Otherwise, we'll
+                // throw WixInvalidIdtException here which is caught in light and turns off tidy.
+                throw new WixInvalidIdtException(idtPath, table.Name);
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Msi/Installer.cs b/src/WixToolset.Core/Msi/Installer.cs
new file mode 100644
index 00000000..3beb26f4
--- /dev/null
+++ b/src/WixToolset.Core/Msi/Installer.cs
@@ -0,0 +1,484 @@
+// 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.Msi
+{
+    using System;
+    using System.Diagnostics;
+    using System.Text;
+    using WixToolset.Core.Native;
+
+    /// <summary>
+    /// Windows Installer message types.
+    /// </summary>
+    [Flags]
+    internal enum InstallMessage
+    {
+        /// <summary>
+        /// Premature termination, possibly fatal out of memory.
+        /// </summary>
+        FatalExit = 0x00000000,
+
+        /// <summary>
+        /// Formatted error message, [1] is message number in Error table.
+        /// </summary>
+        Error = 0x01000000,
+
+        /// <summary>
+        /// Formatted warning message, [1] is message number in Error table.
+        /// </summary>
+        Warning = 0x02000000,
+
+        /// <summary>
+        /// User request message, [1] is message number in Error table.
+        /// </summary>
+        User = 0x03000000,
+
+        /// <summary>
+        /// Informative message for log, not to be displayed.
+        /// </summary>
+        Info = 0x04000000,
+
+        /// <summary>
+        /// List of files in use that need to be replaced.
+        /// </summary>
+        FilesInUse = 0x05000000,
+
+        /// <summary>
+        /// Request to determine a valid source location.
+        /// </summary>
+        ResolveSource = 0x06000000,
+
+        /// <summary>
+        /// Insufficient disk space message.
+        /// </summary>
+        OutOfDiskSpace = 0x07000000,
+
+        /// <summary>
+        /// Progress: start of action, [1] action name, [2] description, [3] template for ACTIONDATA messages.
+        /// </summary>
+        ActionStart = 0x08000000,
+
+        /// <summary>
+        /// Action data. Record fields correspond to the template of ACTIONSTART message.
+        /// </summary>
+        ActionData = 0x09000000,
+
+        /// <summary>
+        /// Progress bar information. See the description of record fields below.
+        /// </summary>
+        Progress = 0x0A000000,
+
+        /// <summary>
+        /// To enable the Cancel button set [1] to 2 and [2] to 1. To disable the Cancel button set [1] to 2 and [2] to 0.
+        /// </summary>
+        CommonData = 0x0B000000,
+
+        /// <summary>
+        /// Sent prior to UI initialization, no string data.
+        /// </summary>
+        Initilize = 0x0C000000,
+
+        /// <summary>
+        /// Sent after UI termination, no string data.
+        /// </summary>
+        Terminate = 0x0D000000,
+
+        /// <summary>
+        /// Sent prior to display or authored dialog or wizard.
+        /// </summary>
+        ShowDialog = 0x0E000000
+    }
+
+    /// <summary>
+    /// Windows Installer log modes.
+    /// </summary>
+    [Flags]
+    internal enum InstallLogModes
+    {
+        /// <summary>
+        /// Premature termination of installation.
+        /// </summary>
+        FatalExit = (1 << ((int)InstallMessage.FatalExit >> 24)),
+
+        /// <summary>
+        /// The error messages are logged.
+        /// </summary>
+        Error = (1 << ((int)InstallMessage.Error >> 24)),
+
+        /// <summary>
+        /// The warning messages are logged.
+        /// </summary>
+        Warning = (1 << ((int)InstallMessage.Warning >> 24)),
+
+        /// <summary>
+        /// The user requests are logged.
+        /// </summary>
+        User = (1 << ((int)InstallMessage.User >> 24)),
+
+        /// <summary>
+        /// The status messages that are not displayed are logged.
+        /// </summary>
+        Info = (1 << ((int)InstallMessage.Info >> 24)),
+
+        /// <summary>
+        /// Request to determine a valid source location.
+        /// </summary>
+        ResolveSource = (1 << ((int)InstallMessage.ResolveSource >> 24)),
+
+        /// <summary>
+        /// The was insufficient disk space.
+        /// </summary>
+        OutOfDiskSpace = (1 << ((int)InstallMessage.OutOfDiskSpace >> 24)),
+
+        /// <summary>
+        /// The start of new installation actions are logged.
+        /// </summary>
+        ActionStart = (1 << ((int)InstallMessage.ActionStart >> 24)),
+
+        /// <summary>
+        /// The data record with the installation action is logged.
+        /// </summary>
+        ActionData = (1 << ((int)InstallMessage.ActionData >> 24)),
+
+        /// <summary>
+        /// The parameters for user-interface initialization are logged.
+        /// </summary>
+        CommonData = (1 << ((int)InstallMessage.CommonData >> 24)),
+
+        /// <summary>
+        /// Logs the property values at termination.
+        /// </summary>
+        PropertyDump = (1 << ((int)InstallMessage.Progress >> 24)),
+
+        /// <summary>
+        /// Sends large amounts of information to a log file not generally useful to users.
+        /// May be used for technical support.
+        /// </summary>
+        Verbose = (1 << ((int)InstallMessage.Initilize >> 24)),
+
+        /// <summary>
+        /// Sends extra debugging information, such as handle creation information, to the log file.
+        /// </summary>
+        ExtraDebug = (1 << ((int)InstallMessage.Terminate >> 24)),
+
+        /// <summary>
+        /// Progress bar information. This message includes information on units so far and total number of units.
+        /// See MsiProcessMessage for an explanation of the message format.
+        /// This message is only sent to an external user interface and is not logged.
+        /// </summary>
+        Progress = (1 << ((int)InstallMessage.Progress >> 24)),
+
+        /// <summary>
+        /// If this is not a quiet installation, then the basic UI has been initialized.
+        /// If this is a full UI installation, the full UI is not yet initialized.
+        /// This message is only sent to an external user interface and is not logged.
+        /// </summary>
+        Initialize = (1 << ((int)InstallMessage.Initilize >> 24)),
+
+        /// <summary>
+        /// If a full UI is being used, the full UI has ended.
+        /// If this is not a quiet installation, the basic UI has not yet ended.
+        /// This message is only sent to an external user interface and is not logged.
+        /// </summary>
+        Terminate = (1 << ((int)InstallMessage.Terminate >> 24)),
+
+        /// <summary>
+        /// Sent prior to display of the full UI dialog.
+        /// This message is only sent to an external user interface and is not logged.
+        /// </summary>
+        ShowDialog = (1 << ((int)InstallMessage.ShowDialog >> 24)),
+
+        /// <summary>
+        /// Files in use information. When this message is received, a FilesInUse Dialog should be displayed.
+        /// </summary>
+        FilesInUse = (1 << ((int)InstallMessage.FilesInUse >> 24))
+    }
+
+    /// <summary>
+    /// Windows Installer UI levels.
+    /// </summary>
+    [Flags]
+    internal enum InstallUILevels
+    {
+        /// <summary>
+        /// No change in the UI level. However, if phWnd is not Null, the parent window can change.
+        /// </summary>
+        NoChange = 0,
+
+        /// <summary>
+        /// The installer chooses an appropriate user interface level.
+        /// </summary>
+        Default = 1,
+
+        /// <summary>
+        /// Completely silent installation.
+        /// </summary>
+        None = 2,
+
+        /// <summary>
+        /// Simple progress and error handling.
+        /// </summary>
+        Basic = 3,
+
+        /// <summary>
+        /// Authored user interface with wizard dialog boxes suppressed.
+        /// </summary>
+        Reduced = 4,
+
+        /// <summary>
+        /// Authored user interface with wizards, progress, and errors.
+        /// </summary>
+        Full = 5,
+
+        /// <summary>
+        /// If combined with the Basic value, the installer shows simple progress dialog boxes but
+        /// does not display a Cancel button on the dialog. This prevents users from canceling the install.
+        /// Available with Windows Installer version 2.0.
+        /// </summary>
+        HideCancel = 0x20,
+
+        /// <summary>
+        /// If combined with the Basic value, the installer shows simple progress
+        /// dialog boxes but does not display any modal dialog boxes or error dialog boxes.
+        /// </summary>
+        ProgressOnly = 0x40,
+
+        /// <summary>
+        /// If combined with any above value, the installer displays a modal dialog
+        /// box at the end of a successful installation or if there has been an error.
+        /// No dialog box is displayed if the user cancels.
+        /// </summary>
+        EndDialog = 0x80,
+
+        /// <summary>
+        /// If this value is combined with the None value, the installer displays only the dialog
+        /// boxes used for source resolution. No other dialog boxes are shown. This value has no
+        /// effect if the UI level is not INSTALLUILEVEL_NONE. It is used with an external user
+        /// interface designed to handle all of the UI except for source resolution. In this case,
+        /// the installer handles source resolution. This value is only available with Windows Installer 2.0 and later.
+        /// </summary>
+        SourceResOnly = 0x100
+    }
+
+    /// <summary>
+    /// Represents the Windows Installer, provides wrappers to
+    /// create the top-level objects and access their methods.
+    /// </summary>
+    internal sealed class Installer
+    {
+        /// <summary>
+        /// Protect the constructor.
+        /// </summary>
+        private Installer()
+        {
+        }
+
+        /// <summary>
+        /// Takes the path to a file and returns a 128-bit hash of that file.
+        /// </summary>
+        /// <param name="filePath">Path to file that is to be hashed.</param>
+        /// <param name="options">The value in this column must be 0. This parameter is reserved for future use.</param>
+        /// <param name="hash">Int array that receives the returned file hash information.</param>
+        internal static void GetFileHash(string filePath, int options, out int[] hash)
+        {
+            MsiInterop.MSIFILEHASHINFO hashInterop = new MsiInterop.MSIFILEHASHINFO();
+            hashInterop.FileHashInfoSize = 20;
+
+            int error = MsiInterop.MsiGetFileHash(filePath, Convert.ToUInt32(options), hashInterop);
+            if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+
+            Debug.Assert(20 == hashInterop.FileHashInfoSize);
+
+            hash = new int[4];
+            hash[0] = hashInterop.Data0;
+            hash[1] = hashInterop.Data1;
+            hash[2] = hashInterop.Data2;
+            hash[3] = hashInterop.Data3;
+        }
+
+        /// <summary>
+        /// Returns the version string and language string in the format that the installer 
+        /// expects to find them in the database.  If you just want version information, set 
+        /// lpLangBuf and pcchLangBuf to zero. If you just want language information, set 
+        /// lpVersionBuf and pcchVersionBuf to zero.
+        /// </summary>
+        /// <param name="filePath">Specifies the path to the file.</param>
+        /// <param name="version">Returns the file version. Set to 0 for language information only.</param>
+        /// <param name="language">Returns the file language. Set to 0 for version information only.</param>
+        internal static void GetFileVersion(string filePath, out string version, out string language)
+        {
+            int versionLength = 20;
+            int languageLength = 20;
+            StringBuilder versionBuffer = new StringBuilder(versionLength);
+            StringBuilder languageBuffer = new StringBuilder(languageLength);
+
+            int error = MsiInterop.MsiGetFileVersion(filePath, versionBuffer, ref versionLength, languageBuffer, ref languageLength);
+            if (234 == error)
+            {
+                versionBuffer.EnsureCapacity(++versionLength);
+                languageBuffer.EnsureCapacity(++languageLength);
+                error = MsiInterop.MsiGetFileVersion(filePath, versionBuffer, ref versionLength, languageBuffer, ref languageLength);
+            }
+            else if (1006 == error)
+            {
+                // file has no version or language, so no error
+                error = 0;
+            }
+
+            if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+
+            version = versionBuffer.ToString();
+            language = languageBuffer.ToString();
+        }
+
+        /// <summary>
+        /// Enables an external user-interface handler.
+        /// </summary>
+        /// <param name="installUIHandler">Specifies a callback function.</param>
+        /// <param name="messageFilter">Specifies which messages to handle using the external message handler.</param>
+        /// <param name="context">Pointer to an application context that is passed to the callback function.</param>
+        /// <returns>The return value is the previously set external handler, or null if there was no previously set handler.</returns>
+        internal static InstallUIHandler SetExternalUI(InstallUIHandler installUIHandler, int messageFilter, IntPtr context)
+        {
+            return MsiInterop.MsiSetExternalUI(installUIHandler, messageFilter, context);
+        }
+
+        /// <summary>
+        /// Enables the installer's internal user interface.
+        /// </summary>
+        /// <param name="uiLevel">Specifies the level of complexity of the user interface.</param>
+        /// <param name="hwnd">Pointer to a window. This window becomes the owner of any user interface created.</param>
+        /// <returns>The previous user interface level is returned. If an invalid dwUILevel is passed, then INSTALLUILEVEL_NOCHANGE is returned.</returns>
+        internal static int SetInternalUI(int uiLevel, ref IntPtr hwnd)
+        {
+            return MsiInterop.MsiSetInternalUI(uiLevel, ref hwnd);
+        }
+
+        /// <summary>
+        /// Get the source/target and short/long file names from an MSI Filename column.
+        /// </summary>
+        /// <param name="value">The Filename value.</param>
+        /// <returns>An array of strings of length 4.  The contents are: short target, long target, short source, and long source.</returns>
+        /// <remarks>
+        /// If any particular file name part is not parsed, its set to null in the appropriate location of the returned array of strings.
+        /// However, the returned array will always be of length 4.
+        /// </remarks>
+        internal static string[] GetNames(string value)
+        {
+            string[] names = new string[4];
+            int targetSeparator = value.IndexOf(":", StringComparison.Ordinal);
+
+            // split source and target
+            string sourceName = null;
+            string targetName = value;
+            if (0 <= targetSeparator)
+            {
+                sourceName = value.Substring(targetSeparator + 1);
+                targetName = value.Substring(0, targetSeparator);
+            }
+
+            // split the source short and long names
+            string sourceLongName = null;
+            if (null != sourceName)
+            {
+                int sourceLongNameSeparator = sourceName.IndexOf("|", StringComparison.Ordinal);
+                if (0 <= sourceLongNameSeparator)
+                {
+                    sourceLongName = sourceName.Substring(sourceLongNameSeparator + 1);
+                    sourceName = sourceName.Substring(0, sourceLongNameSeparator);
+                }
+            }
+
+            // split the target short and long names
+            int targetLongNameSeparator = targetName.IndexOf("|", StringComparison.Ordinal);
+            string targetLongName = null;
+            if (0 <= targetLongNameSeparator)
+            {
+                targetLongName = targetName.Substring(targetLongNameSeparator + 1);
+                targetName = targetName.Substring(0, targetLongNameSeparator);
+            }
+
+            // remove the long source name when its identical to the long source name
+            if (null != sourceName && sourceName == sourceLongName)
+            {
+                sourceLongName = null;
+            }
+
+            // remove the long target name when its identical to the long target name
+            if (null != targetName && targetName == targetLongName)
+            {
+                targetLongName = null;
+            }
+
+            // remove the source names when they are identical to the target names
+            if (sourceName == targetName && sourceLongName == targetLongName)
+            {
+                sourceName = null;
+                sourceLongName = null;
+            }
+
+            // target name(s)
+            if ("." != targetName)
+            {
+                names[0] = targetName;
+            }
+
+            if (null != targetLongName && "." != targetLongName)
+            {
+                names[1] = targetLongName;
+            }
+
+            // source name(s)
+            if (null != sourceName)
+            {
+                names[2] = sourceName;
+            }
+
+            if (null != sourceLongName && "." != sourceLongName)
+            {
+                names[3] = sourceLongName;
+            }
+
+            return names;
+        }
+
+        /// <summary>
+        /// Get a source/target and short/long file name from an MSI Filename column.
+        /// </summary>
+        /// <param name="value">The Filename value.</param>
+        /// <param name="source">true to get a source name; false to get a target name</param>
+        /// <param name="longName">true to get a long name; false to get a short name</param>
+        /// <returns>The name.</returns>
+        internal static string GetName(string value, bool source, bool longName)
+        {
+            string[] names = GetNames(value);
+
+            if (source)
+            {
+                if (longName && null != names[3])
+                {
+                    return names[3];
+                }
+                else if (null != names[2])
+                {
+                    return names[2];
+                }
+            }
+
+            if (longName && null != names[1])
+            {
+                return names[1];
+            }
+            else
+            {
+                return names[0];
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Msi/Interop/MsiInterop.cs b/src/WixToolset.Core/Msi/Interop/MsiInterop.cs
new file mode 100644
index 00000000..054289ee
--- /dev/null
+++ b/src/WixToolset.Core/Msi/Interop/MsiInterop.cs
@@ -0,0 +1,697 @@
+// 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.
+#if false
+namespace WixToolset.Msi.Interop
+{
+    using System;
+    using System.Text;
+    using System.Runtime.InteropServices;
+    using FILETIME = System.Runtime.InteropServices.ComTypes.FILETIME;
+
+    /// <summary>
+    /// A callback function that the installer calls for progress notification and error messages.
+    /// </summary>
+    /// <param name="context">Pointer to an application context.
+    /// This parameter can be used for error checking.</param>
+    /// <param name="messageType">Specifies a combination of one message box style,
+    /// one message box icon type, one default button, and one installation message type.</param>
+    /// <param name="message">Specifies the message text.</param>
+    /// <returns>-1 for an error, 0 if no action was taken, 1 if OK, 3 to abort.</returns>
+    internal delegate int InstallUIHandler(IntPtr context, uint messageType, [MarshalAs(UnmanagedType.LPWStr)] string message);
+
+    /// <summary>
+    /// Class exposing static functions and structs from MSI API.
+    /// </summary>
+    internal sealed class MsiInterop
+    {
+        // Patching constants
+        internal const int MsiMaxStreamNameLength = 62; // http://msdn2.microsoft.com/library/aa370551.aspx
+
+        // Component.Attributes
+        internal const int MsidbComponentAttributesLocalOnly = 0;
+        internal const int MsidbComponentAttributesSourceOnly = 1;
+        internal const int MsidbComponentAttributesOptional = 2;
+        internal const int MsidbComponentAttributesRegistryKeyPath = 4;
+        internal const int MsidbComponentAttributesSharedDllRefCount = 8;
+        internal const int MsidbComponentAttributesPermanent = 16;
+        internal const int MsidbComponentAttributesODBCDataSource = 32;
+        internal const int MsidbComponentAttributesTransitive = 64;
+        internal const int MsidbComponentAttributesNeverOverwrite = 128;
+        internal const int MsidbComponentAttributes64bit = 256;
+        internal const int MsidbComponentAttributesDisableRegistryReflection = 512;
+        internal const int MsidbComponentAttributesUninstallOnSupersedence = 1024;
+        internal const int MsidbComponentAttributesShared = 2048;
+
+        // BBControl.Attributes & Control.Attributes
+        internal const int MsidbControlAttributesVisible           = 0x00000001;
+        internal const int MsidbControlAttributesEnabled           = 0x00000002;
+        internal const int MsidbControlAttributesSunken            = 0x00000004;
+        internal const int MsidbControlAttributesIndirect          = 0x00000008;
+        internal const int MsidbControlAttributesInteger           = 0x00000010;
+        internal const int MsidbControlAttributesRTLRO             = 0x00000020;
+        internal const int MsidbControlAttributesRightAligned      = 0x00000040;
+        internal const int MsidbControlAttributesLeftScroll        = 0x00000080;
+        internal const int MsidbControlAttributesBiDi              = MsidbControlAttributesRTLRO | MsidbControlAttributesRightAligned | MsidbControlAttributesLeftScroll;
+
+        // Text controls
+        internal const int MsidbControlAttributesTransparent       = 0x00010000;
+        internal const int MsidbControlAttributesNoPrefix          = 0x00020000;
+        internal const int MsidbControlAttributesNoWrap            = 0x00040000;
+        internal const int MsidbControlAttributesFormatSize        = 0x00080000;
+        internal const int MsidbControlAttributesUsersLanguage     = 0x00100000;
+
+        // Edit controls
+        internal const int MsidbControlAttributesMultiline         = 0x00010000;
+        internal const int MsidbControlAttributesPasswordInput     = 0x00200000;
+
+        // ProgressBar controls
+        internal const int MsidbControlAttributesProgress95        = 0x00010000;
+
+        // VolumeSelectCombo and DirectoryCombo controls
+        internal const int MsidbControlAttributesRemovableVolume   = 0x00010000;
+        internal const int MsidbControlAttributesFixedVolume       = 0x00020000;
+        internal const int MsidbControlAttributesRemoteVolume      = 0x00040000;
+        internal const int MsidbControlAttributesCDROMVolume       = 0x00080000;
+        internal const int MsidbControlAttributesRAMDiskVolume     = 0x00100000;
+        internal const int MsidbControlAttributesFloppyVolume      = 0x00200000;
+
+        // VolumeCostList controls
+        internal const int MsidbControlShowRollbackCost            = 0x00400000;
+
+        // ListBox and ComboBox controls
+        internal const int MsidbControlAttributesSorted            = 0x00010000;
+        internal const int MsidbControlAttributesComboList         = 0x00020000;
+
+        // picture button controls
+        internal const int MsidbControlAttributesImageHandle       = 0x00010000;
+        internal const int MsidbControlAttributesPushLike          = 0x00020000;
+        internal const int MsidbControlAttributesBitmap            = 0x00040000;
+        internal const int MsidbControlAttributesIcon              = 0x00080000;
+        internal const int MsidbControlAttributesFixedSize         = 0x00100000;
+        internal const int MsidbControlAttributesIconSize16        = 0x00200000;
+        internal const int MsidbControlAttributesIconSize32        = 0x00400000;
+        internal const int MsidbControlAttributesIconSize48        = 0x00600000;
+        internal const int MsidbControlAttributesElevationShield   = 0x00800000;
+
+        // RadioButton controls
+        internal const int MsidbControlAttributesHasBorder         = 0x01000000;
+
+        // CustomAction.Type
+        // executable types
+        internal const int MsidbCustomActionTypeDll              = 0x00000001;  // Target = entry point name
+        internal const int MsidbCustomActionTypeExe              = 0x00000002;  // Target = command line args
+        internal const int MsidbCustomActionTypeTextData         = 0x00000003;  // Target = text string to be formatted and set into property
+        internal const int MsidbCustomActionTypeJScript          = 0x00000005;  // Target = entry point name; null if none to call
+        internal const int MsidbCustomActionTypeVBScript         = 0x00000006;  // Target = entry point name; null if none to call
+        internal const int MsidbCustomActionTypeInstall          = 0x00000007;  // Target = property list for nested engine initialization
+        internal const int MsidbCustomActionTypeSourceBits       = 0x00000030;
+        internal const int MsidbCustomActionTypeTargetBits       = 0x00000007;
+        internal const int MsidbCustomActionTypeReturnBits       = 0x000000C0;
+        internal const int MsidbCustomActionTypeExecuteBits      = 0x00000700;
+
+        // source of code
+        internal const int MsidbCustomActionTypeBinaryData       = 0x00000000;  // Source = Binary.Name; data stored in stream
+        internal const int MsidbCustomActionTypeSourceFile       = 0x00000010;  // Source = File.File; file part of installation
+        internal const int MsidbCustomActionTypeDirectory        = 0x00000020;  // Source = Directory.Directory; folder containing existing file
+        internal const int MsidbCustomActionTypeProperty         = 0x00000030;  // Source = Property.Property; full path to executable
+
+        // return processing; default is syncronous execution; process return code
+        internal const int MsidbCustomActionTypeContinue         = 0x00000040;  // ignore action return status; continue running
+        internal const int MsidbCustomActionTypeAsync            = 0x00000080;  // run asynchronously
+
+        // execution scheduling flags; default is execute whenever sequenced
+        internal const int MsidbCustomActionTypeFirstSequence    = 0x00000100;  // skip if UI sequence already run
+        internal const int MsidbCustomActionTypeOncePerProcess   = 0x00000200;  // skip if UI sequence already run in same process
+        internal const int MsidbCustomActionTypeClientRepeat     = 0x00000300;  // run on client only if UI already run on client
+        internal const int MsidbCustomActionTypeInScript         = 0x00000400;  // queue for execution within script
+        internal const int MsidbCustomActionTypeRollback         = 0x00000100;  // in conjunction with InScript: queue in Rollback script
+        internal const int MsidbCustomActionTypeCommit           = 0x00000200;  // in conjunction with InScript: run Commit ops from script on success
+
+        // security context flag; default to impersonate as user; valid only if InScript
+        internal const int MsidbCustomActionTypeNoImpersonate    = 0x00000800;  // no impersonation; run in system context
+        internal const int MsidbCustomActionTypeTSAware          = 0x00004000;  // impersonate for per-machine installs on TS machines
+        internal const int MsidbCustomActionType64BitScript      = 0x00001000;  // script should run in 64bit process
+        internal const int MsidbCustomActionTypeHideTarget       = 0x00002000;  // don't record the contents of the Target field in the log file.
+
+        internal const int MsidbCustomActionTypePatchUninstall   = 0x00008000;  // run on patch uninstall
+
+        // Dialog.Attributes
+        internal const int MsidbDialogAttributesVisible          = 0x00000001;
+        internal const int MsidbDialogAttributesModal            = 0x00000002;
+        internal const int MsidbDialogAttributesMinimize         = 0x00000004;
+        internal const int MsidbDialogAttributesSysModal         = 0x00000008;
+        internal const int MsidbDialogAttributesKeepModeless     = 0x00000010;
+        internal const int MsidbDialogAttributesTrackDiskSpace   = 0x00000020;
+        internal const int MsidbDialogAttributesUseCustomPalette = 0x00000040;
+        internal const int MsidbDialogAttributesRTLRO            = 0x00000080;
+        internal const int MsidbDialogAttributesRightAligned     = 0x00000100;
+        internal const int MsidbDialogAttributesLeftScroll       = 0x00000200;
+        internal const int MsidbDialogAttributesBiDi             = MsidbDialogAttributesRTLRO | MsidbDialogAttributesRightAligned | MsidbDialogAttributesLeftScroll;
+        internal const int MsidbDialogAttributesError            = 0x00010000;
+        internal const int CommonControlAttributesInvert         = MsidbControlAttributesVisible + MsidbControlAttributesEnabled;
+        internal const int DialogAttributesInvert                = MsidbDialogAttributesVisible + MsidbDialogAttributesModal + MsidbDialogAttributesMinimize;
+
+        // Feature.Attributes
+        internal const int MsidbFeatureAttributesFavorLocal = 0;
+        internal const int MsidbFeatureAttributesFavorSource = 1;
+        internal const int MsidbFeatureAttributesFollowParent = 2;
+        internal const int MsidbFeatureAttributesFavorAdvertise = 4;
+        internal const int MsidbFeatureAttributesDisallowAdvertise = 8;
+        internal const int MsidbFeatureAttributesUIDisallowAbsent = 16;
+        internal const int MsidbFeatureAttributesNoUnsupportedAdvertise = 32;
+
+        // File.Attributes
+        internal const int MsidbFileAttributesReadOnly = 1;
+        internal const int MsidbFileAttributesHidden = 2;
+        internal const int MsidbFileAttributesSystem = 4;
+        internal const int MsidbFileAttributesVital = 512;
+        internal const int MsidbFileAttributesChecksum = 1024;
+        internal const int MsidbFileAttributesPatchAdded = 4096;
+        internal const int MsidbFileAttributesNoncompressed = 8192;
+        internal const int MsidbFileAttributesCompressed = 16384;
+
+        // IniFile.Action & RemoveIniFile.Action
+        internal const int MsidbIniFileActionAddLine    = 0;
+        internal const int MsidbIniFileActionCreateLine = 1;
+        internal const int MsidbIniFileActionRemoveLine = 2;
+        internal const int MsidbIniFileActionAddTag     = 3;
+        internal const int MsidbIniFileActionRemoveTag  = 4;
+
+        // MoveFile.Options
+        internal const int MsidbMoveFileOptionsMove = 1;
+
+        // ServiceInstall.Attributes
+        internal const int MsidbServiceInstallOwnProcess        = 0x00000010;
+        internal const int MsidbServiceInstallShareProcess      = 0x00000020;
+        internal const int MsidbServiceInstallInteractive       = 0x00000100;
+        internal const int MsidbServiceInstallAutoStart         = 0x00000002;
+        internal const int MsidbServiceInstallDemandStart       = 0x00000003;
+        internal const int MsidbServiceInstallDisabled          = 0x00000004;
+        internal const int MsidbServiceInstallErrorIgnore       = 0x00000000;
+        internal const int MsidbServiceInstallErrorNormal       = 0x00000001;
+        internal const int MsidbServiceInstallErrorCritical     = 0x00000003;
+        internal const int MsidbServiceInstallErrorControlVital = 0x00008000;
+
+        // ServiceConfig.Event
+        internal const int MsidbServiceConfigEventInstall       = 0x00000001;
+        internal const int MsidbServiceConfigEventUninstall     = 0x00000002;
+        internal const int MsidbServiceConfigEventReinstall     = 0x00000004;
+
+        // ServiceControl.Attributes
+        internal const int MsidbServiceControlEventStart           = 0x00000001;
+        internal const int MsidbServiceControlEventStop            = 0x00000002;
+        internal const int MsidbServiceControlEventDelete          = 0x00000008;
+        internal const int MsidbServiceControlEventUninstallStart  = 0x00000010;
+        internal const int MsidbServiceControlEventUninstallStop   = 0x00000020;
+        internal const int MsidbServiceControlEventUninstallDelete = 0x00000080;
+
+        // TextStyle.StyleBits
+        internal const int MsidbTextStyleStyleBitsBold      = 1;
+        internal const int MsidbTextStyleStyleBitsItalic    = 2;
+        internal const int MsidbTextStyleStyleBitsUnderline = 4;
+        internal const int MsidbTextStyleStyleBitsStrike    = 8;
+
+        // Upgrade.Attributes
+        internal const int MsidbUpgradeAttributesMigrateFeatures     = 0x00000001;
+        internal const int MsidbUpgradeAttributesOnlyDetect          = 0x00000002;
+        internal const int MsidbUpgradeAttributesIgnoreRemoveFailure = 0x00000004;
+        internal const int MsidbUpgradeAttributesVersionMinInclusive = 0x00000100;
+        internal const int MsidbUpgradeAttributesVersionMaxInclusive = 0x00000200;
+        internal const int MsidbUpgradeAttributesLanguagesExclusive  = 0x00000400;
+
+        // Registry Hive Roots
+        internal const int MsidbRegistryRootClassesRoot = 0;
+        internal const int MsidbRegistryRootCurrentUser = 1;
+        internal const int MsidbRegistryRootLocalMachine = 2;
+        internal const int MsidbRegistryRootUsers = 3;
+
+        // Locator Types
+        internal const int MsidbLocatorTypeDirectory = 0;
+        internal const int MsidbLocatorTypeFileName = 1;
+        internal const int MsidbLocatorTypeRawValue = 2;
+        internal const int MsidbLocatorType64bit = 16;
+
+        internal const int MsidbClassAttributesRelativePath = 1;
+
+        // RemoveFile.InstallMode
+        internal const int MsidbRemoveFileInstallModeOnInstall = 0x00000001;
+        internal const int MsidbRemoveFileInstallModeOnRemove  = 0x00000002;
+        internal const int MsidbRemoveFileInstallModeOnBoth    = 0x00000003;
+
+        // ODBCDataSource.Registration
+        internal const int MsidbODBCDataSourceRegistrationPerMachine = 0;
+        internal const int MsidbODBCDataSourceRegistrationPerUser    = 1;
+
+        // ModuleConfiguration.Format
+        internal const int MsidbModuleConfigurationFormatText = 0;
+        internal const int MsidbModuleConfigurationFormatKey = 1;
+        internal const int MsidbModuleConfigurationFormatInteger = 2;
+        internal const int MsidbModuleConfigurationFormatBitfield = 3;
+
+        // ModuleConfiguration.Attributes
+        internal const int MsidbMsmConfigurableOptionKeyNoOrphan = 1;
+        internal const int MsidbMsmConfigurableOptionNonNullable = 2;
+
+        // ' Windows API function ShowWindow constants - used in Shortcut table
+        internal const int SWSHOWNORMAL                         = 0x00000001;
+        internal const int SWSHOWMAXIMIZED                      = 0x00000003;
+        internal const int SWSHOWMINNOACTIVE                    = 0x00000007;
+
+        // NameToBit arrays
+        // UI elements
+        internal static readonly string[] CommonControlAttributes = { "Hidden", "Disabled", "Sunken", "Indirect", "Integer", "RightToLeft", "RightAligned", "LeftScroll" };
+        internal static readonly string[] TextControlAttributes = { "Transparent", "NoPrefix", "NoWrap", "FormatSize", "UserLanguage" };
+        internal static readonly string[] HyperlinkControlAttributes = { "Transparent" };
+        internal static readonly string[] EditControlAttributes = { "Multiline", null, null, null,    null, "Password" };
+        internal static readonly string[] ProgressControlAttributes = { "ProgressBlocks" };
+        internal static readonly string[] VolumeControlAttributes = { "Removable", "Fixed", "Remote", "CDROM", "RAMDisk", "Floppy", "ShowRollbackCost" };
+        internal static readonly string[] ListboxControlAttributes = { "Sorted", null, null, null, "UserLanguage" };
+        internal static readonly string[] ListviewControlAttributes = { "Sorted", null, null, null, "FixedSize", "Icon16", "Icon32" };
+        internal static readonly string[] ComboboxControlAttributes = { "Sorted", "ComboList", null, null, "UserLanguage" };
+        internal static readonly string[] RadioControlAttributes = { "Image", "PushLike", "Bitmap", "Icon", "FixedSize", "Icon16", "Icon32", null, "HasBorder" };
+        internal static readonly string[] ButtonControlAttributes = { "Image", null, "Bitmap", "Icon", "FixedSize", "Icon16", "Icon32", "ElevationShield" };
+        internal static readonly string[] IconControlAttributes = { "Image", null, null, null, "FixedSize", "Icon16", "Icon32" };
+        internal static readonly string[] BitmapControlAttributes = { "Image", null, null, null, "FixedSize" };
+        internal static readonly string[] CheckboxControlAttributes = { null, "PushLike", "Bitmap", "Icon", "FixedSize", "Icon16", "Icon32" };
+
+        internal const int MsidbEmbeddedUI                      = 0x01;
+        internal const int MsidbEmbeddedHandlesBasic            = 0x02;
+
+        internal const int INSTALLLOGMODE_FATALEXIT             = 0x00001;
+        internal const int INSTALLLOGMODE_ERROR                 = 0x00002;
+        internal const int INSTALLLOGMODE_WARNING               = 0x00004;
+        internal const int INSTALLLOGMODE_USER                  = 0x00008;
+        internal const int INSTALLLOGMODE_INFO                  = 0x00010;
+        internal const int INSTALLLOGMODE_FILESINUSE            = 0x00020;
+        internal const int INSTALLLOGMODE_RESOLVESOURCE         = 0x00040;
+        internal const int INSTALLLOGMODE_OUTOFDISKSPACE        = 0x00080;
+        internal const int INSTALLLOGMODE_ACTIONSTART           = 0x00100;
+        internal const int INSTALLLOGMODE_ACTIONDATA            = 0x00200;
+        internal const int INSTALLLOGMODE_PROGRESS              = 0x00400;
+        internal const int INSTALLLOGMODE_COMMONDATA            = 0x00800;
+        internal const int INSTALLLOGMODE_INITIALIZE            = 0x01000;
+        internal const int INSTALLLOGMODE_TERMINATE             = 0x02000;
+        internal const int INSTALLLOGMODE_SHOWDIALOG            = 0x04000;
+        internal const int INSTALLLOGMODE_RMFILESINUSE       = 0x02000000;
+        internal const int INSTALLLOGMODE_INSTALLSTART       = 0x04000000;
+        internal const int INSTALLLOGMODE_INSTALLEND         = 0x08000000;
+
+        internal const int MSICONDITIONFALSE = 0;   // The table is temporary.
+        internal const int MSICONDITIONTRUE = 1;   // The table is persistent.
+        internal const int MSICONDITIONNONE = 2;   // The table is unknown.
+        internal const int MSICONDITIONERROR = 3;   // An invalid handle or invalid parameter was passed to the function.
+
+        internal const int MSIDBOPENREADONLY = 0;
+        internal const int MSIDBOPENTRANSACT = 1;
+        internal const int MSIDBOPENDIRECT = 2;
+        internal const int MSIDBOPENCREATE = 3;
+        internal const int MSIDBOPENCREATEDIRECT = 4;
+        internal const int MSIDBOPENPATCHFILE = 32;
+
+        internal const int MSIMODIFYSEEK = -1;   // Refreshes the information in the supplied record without changing the position in the result set and without affecting subsequent fetch operations. The record may then be used for subsequent Update, Delete, and Refresh. All primary key columns of the table must be in the query and the record must have at least as many fields as the query. Seek cannot be used with multi-table queries. This mode cannot be used with a view containing joins. See also the remarks.
+        internal const int MSIMODIFYREFRESH = 0;   // Refreshes the information in the record. Must first call MsiViewFetch with the same record. Fails for a deleted row. Works with read-write and read-only records.
+        internal const int MSIMODIFYINSERT = 1;   // Inserts a record. Fails if a row with the same primary keys exists. Fails with a read-only database. This mode cannot be used with a view containing joins.
+        internal const int MSIMODIFYUPDATE = 2;   // Updates an existing record. Nonprimary keys only. Must first call MsiViewFetch. Fails with a deleted record. Works only with read-write records.
+        internal const int MSIMODIFYASSIGN = 3;   // Writes current data in the cursor to a table row. Updates record if the primary keys match an existing row and inserts if they do not match. Fails with a read-only database. This mode cannot be used with a view containing joins.
+        internal const int MSIMODIFYREPLACE = 4;   // Updates or deletes and inserts a record into a table. Must first call MsiViewFetch with the same record. Updates record if the primary keys are unchanged. Deletes old row and inserts new if primary keys have changed. Fails with a read-only database. This mode cannot be used with a view containing joins.
+        internal const int MSIMODIFYMERGE = 5;   // Inserts or validates a record in a table. Inserts if primary keys do not match any row and validates if there is a match. Fails if the record does not match the data in the table. Fails if there is a record with a duplicate key that is not identical. Works only with read-write records. This mode cannot be used with a view containing joins.
+        internal const int MSIMODIFYDELETE = 6;   // Remove a row from the table. You must first call the MsiViewFetch function with the same record. Fails if the row has been deleted. Works only with read-write records. This mode cannot be used with a view containing joins.
+        internal const int MSIMODIFYINSERTTEMPORARY = 7;   // Inserts a temporary record. The information is not persistent. Fails if a row with the same primary key exists. Works only with read-write records. This mode cannot be used with a view containing joins.
+        internal const int MSIMODIFYVALIDATE = 8;   // Validates a record. Does not validate across joins. You must first call the MsiViewFetch function with the same record. Obtain validation errors with MsiViewGetError. Works with read-write and read-only records. This mode cannot be used with a view containing joins.
+        internal const int MSIMODIFYVALIDATENEW = 9;   // Validate a new record. Does not validate across joins. Checks for duplicate keys. Obtain validation errors by calling MsiViewGetError. Works with read-write and read-only records. This mode cannot be used with a view containing joins.
+        internal const int MSIMODIFYVALIDATEFIELD = 10;   // Validates fields of a fetched or new record. Can validate one or more fields of an incomplete record. Obtain validation errors by calling MsiViewGetError. Works with read-write and read-only records. This mode cannot be used with a view containing joins.
+        internal const int MSIMODIFYVALIDATEDELETE = 11;   // Validates a record that will be deleted later. You must first call MsiViewFetch. Fails if another row refers to the primary keys of this row. Validation does not check for the existence of the primary keys of this row in properties or strings. Does not check if a column is a foreign key to multiple tables. Obtain validation errors by calling MsiViewGetError. Works with read-write and read-only records. This mode cannot be used with a view containing joins.
+
+        internal const uint VTI2 = 2;
+        internal const uint VTI4 = 3;
+        internal const uint VTLPWSTR = 30;
+        internal const uint VTFILETIME = 64;
+
+        internal const int MSICOLINFONAMES = 0;  // return column names
+        internal const int MSICOLINFOTYPES = 1;  // return column definitions, datatype code followed by width
+
+        /// <summary>
+        /// Protect the constructor.
+        /// </summary>
+        private MsiInterop()
+        {
+        }
+
+        /// <summary>
+        /// PInvoke of MsiCloseHandle.
+        /// </summary>
+        /// <param name="database">Handle to a database.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiCloseHandle", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiCloseHandle(uint database);
+
+        /// <summary>
+        /// PInvoke of MsiCreateRecord
+        /// </summary>
+        /// <param name="parameters">Count of columns in the record.</param>
+        /// <returns>Handle referencing the record.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiCreateRecord", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern uint MsiCreateRecord(int parameters);
+
+        /// <summary>
+        /// Creates summary information of an existing transform to include validation and error conditions.
+        /// </summary>
+        /// <param name="database">The handle to the database that contains the new database summary information.</param>
+        /// <param name="referenceDatabase">The handle to the database that contains the original summary information.</param>
+        /// <param name="transformFile">The name of the transform to which the summary information is added.</param>
+        /// <param name="errorConditions">The error conditions that should be suppressed when the transform is applied.</param>
+        /// <param name="validations">Specifies the properties to be validated to verify that the transform can be applied to the database.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiCreateTransformSummaryInfoW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiCreateTransformSummaryInfo(uint database, uint referenceDatabase, string transformFile, TransformErrorConditions errorConditions, TransformValidations validations);
+
+        /// <summary>
+        /// Applies a transform to a database.
+        /// </summary>
+        /// <param name="database">Handle to the database obtained from MsiOpenDatabase to transform.</param>
+        /// <param name="transformFile">Specifies the name of the transform file to apply.</param>
+        /// <param name="errorConditions">Error conditions that should be suppressed.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiDatabaseApplyTransformW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiDatabaseApplyTransform(uint database, string transformFile, TransformErrorConditions errorConditions);
+
+        /// <summary>
+        /// PInvoke of MsiDatabaseCommit.
+        /// </summary>
+        /// <param name="database">Handle to a databse.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiDatabaseCommit", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiDatabaseCommit(uint database);
+
+        /// <summary>
+        /// PInvoke of MsiDatabaseExportW.
+        /// </summary>
+        /// <param name="database">Handle to a database.</param>
+        /// <param name="tableName">Table name.</param>
+        /// <param name="folderPath">Folder path.</param>
+        /// <param name="fileName">File name.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiDatabaseExportW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiDatabaseExport(uint database, string tableName, string folderPath, string fileName);
+
+        /// <summary>
+        /// Generates a transform file of differences between two databases.
+        /// </summary>
+        /// <param name="database">Handle to the database obtained from MsiOpenDatabase that includes the changes.</param>
+        /// <param name="databaseReference">Handle to the database obtained from MsiOpenDatabase that does not include the changes.</param>
+        /// <param name="transformFile">A null-terminated string that specifies the name of the transform file being generated.
+        /// This parameter can be null. If szTransformFile is null, you can use MsiDatabaseGenerateTransform to test whether two
+        /// databases are identical without creating a transform. If the databases are identical, the function returns ERROR_NO_DATA.
+        /// If the databases are different the function returns NOERROR.</param>
+        /// <param name="reserved1">This is a reserved argument and must be set to 0.</param>
+        /// <param name="reserved2">This is a reserved argument and must be set to 0.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiDatabaseGenerateTransformW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiDatabaseGenerateTransform(uint database, uint databaseReference, string transformFile, int reserved1, int reserved2);
+
+        /// <summary>
+        /// PInvoke of MsiDatabaseImportW.
+        /// </summary>
+        /// <param name="database">Handle to a database.</param>
+        /// <param name="folderPath">Folder path.</param>
+        /// <param name="fileName">File name.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiDatabaseImportW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiDatabaseImport(uint database, string folderPath, string fileName);
+
+        /// <summary>
+        /// PInvoke of MsiDatabaseMergeW.
+        /// </summary>
+        /// <param name="database">The handle to the database obtained from MsiOpenDatabase.</param>
+        /// <param name="databaseMerge">The handle to the database obtained from MsiOpenDatabase to merge into the base database.</param>
+        /// <param name="tableName">The name of the table to receive merge conflict information.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiDatabaseMergeW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiDatabaseMerge(uint database, uint databaseMerge, string tableName);
+
+        /// <summary>
+        /// PInvoke of MsiDatabaseOpenViewW.
+        /// </summary>
+        /// <param name="database">Handle to a database.</param>
+        /// <param name="query">SQL query.</param>
+        /// <param name="view">View handle.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiDatabaseOpenViewW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiDatabaseOpenView(uint database, string query, out uint view);
+
+        /// <summary>
+        /// PInvoke of MsiGetFileHashW.
+        /// </summary>
+        /// <param name="filePath">File path.</param>
+        /// <param name="options">Hash options (must be 0).</param>
+        /// <param name="hash">Buffer to recieve hash.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiGetFileHashW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiGetFileHash(string filePath, uint options, MSIFILEHASHINFO hash);
+
+        /// <summary>
+        /// PInvoke of MsiGetFileVersionW.
+        /// </summary>
+        /// <param name="filePath">File path.</param>
+        /// <param name="versionBuf">Buffer to receive version info.</param>
+        /// <param name="versionBufSize">Size of version buffer.</param>
+        /// <param name="langBuf">Buffer to recieve lang info.</param>
+        /// <param name="langBufSize">Size of lang buffer.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiGetFileVersionW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiGetFileVersion(string filePath, StringBuilder versionBuf, ref int versionBufSize, StringBuilder langBuf, ref int langBufSize);
+
+        /// <summary>
+        /// PInvoke of MsiGetLastErrorRecord.
+        /// </summary>
+        /// <returns>Handle to error record if one exists.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiGetLastErrorRecord", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern uint MsiGetLastErrorRecord();
+
+        /// <summary>
+        /// PInvoke of MsiDatabaseGetPrimaryKeysW.
+        /// </summary>
+        /// <param name="database">Handle to a database.</param>
+        /// <param name="tableName">Table name.</param>
+        /// <param name="record">Handle to receive resulting record.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiDatabaseGetPrimaryKeysW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiDatabaseGetPrimaryKeys(uint database, string tableName, out uint record);
+
+        /// <summary>
+        /// PInvoke of MsiDoActionW.
+        /// </summary>
+        /// <param name="product">Handle to the installation provided to a DLL custom action or
+        /// obtained through MsiOpenPackage, MsiOpenPackageEx, or MsiOpenProduct.</param>
+        /// <param name="action">Specifies the action to execute.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiDoActionW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiDoAction(uint product, string action);
+
+        /// <summary>
+        /// PInvoke of MsiGetSummaryInformationW.  Can use either database handle or database path as input.
+        /// </summary>
+        /// <param name="database">Handle to a database.</param>
+        /// <param name="databasePath">Path to a database.</param>
+        /// <param name="updateCount">Max number of updated values.</param>
+        /// <param name="summaryInfo">Handle to summary information.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiGetSummaryInformationW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiGetSummaryInformation(uint database, string databasePath, uint updateCount, ref uint summaryInfo);
+
+        /// <summary>
+        /// PInvoke of MsiDatabaseIsTablePersitentW.
+        /// </summary>
+        /// <param name="database">Handle to a database.</param>
+        /// <param name="tableName">Table name.</param>
+        /// <returns>MSICONDITION</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiDatabaseIsTablePersistentW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiDatabaseIsTablePersistent(uint database, string tableName);
+
+        /// <summary>
+        /// PInvoke of MsiOpenDatabaseW.
+        /// </summary>
+        /// <param name="databasePath">Path to database.</param>
+        /// <param name="persist">Persist mode.</param>
+        /// <param name="database">Handle to database.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiOpenDatabaseW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiOpenDatabase(string databasePath, IntPtr persist, out uint database);
+
+        /// <summary>
+        /// PInvoke of MsiOpenPackageW.
+        /// </summary>
+        /// <param name="packagePath">The path to the package.</param>
+        /// <param name="product">A pointer to a variable that receives the product handle.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiOpenPackageW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiOpenPackage(string packagePath, out uint product);
+
+        /// <summary>
+        /// PInvoke of MsiRecordIsNull.
+        /// </summary>
+        /// <param name="record">MSI Record handle.</param>
+        /// <param name="field">Index of field to check for null value.</param>
+        /// <returns>true if the field is null, false if not, and an error code for any error.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiRecordIsNull", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiRecordIsNull(uint record, int field);
+
+        /// <summary>
+        /// PInvoke of MsiRecordGetInteger.
+        /// </summary>
+        /// <param name="record">MSI Record handle.</param>
+        /// <param name="field">Index of field to retrieve integer from.</param>
+        /// <returns>Integer value.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiRecordGetInteger", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiRecordGetInteger(uint record, int field);
+
+        /// <summary>
+        /// PInvoke of MsiRectordSetInteger.
+        /// </summary>
+        /// <param name="record">MSI Record handle.</param>
+        /// <param name="field">Index of field to set integer value in.</param>
+        /// <param name="value">Value to set field to.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiRecordSetInteger", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiRecordSetInteger(uint record, int field, int value);
+
+        /// <summary>
+        /// PInvoke of MsiRecordGetStringW.
+        /// </summary>
+        /// <param name="record">MSI Record handle.</param>
+        /// <param name="field">Index of field to get string value from.</param>
+        /// <param name="valueBuf">Buffer to recieve value.</param>
+        /// <param name="valueBufSize">Size of buffer.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiRecordGetStringW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiRecordGetString(uint record, int field, StringBuilder valueBuf, ref int valueBufSize);
+
+        /// <summary>
+        /// PInvoke of MsiRecordSetStringW.
+        /// </summary>
+        /// <param name="record">MSI Record handle.</param>
+        /// <param name="field">Index of field to set string value in.</param>
+        /// <param name="value">String value.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiRecordSetStringW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiRecordSetString(uint record, int field, string value);
+
+        /// <summary>
+        /// PInvoke of MsiRecordSetStreamW.
+        /// </summary>
+        /// <param name="record">MSI Record handle.</param>
+        /// <param name="field">Index of field to set stream value in.</param>
+        /// <param name="filePath">Path to file to set stream value to.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiRecordSetStreamW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiRecordSetStream(uint record, int field, string filePath);
+
+        /// <summary>
+        /// PInvoke of MsiRecordReadStreamW.
+        /// </summary>
+        /// <param name="record">MSI Record handle.</param>
+        /// <param name="field">Index of field to read stream from.</param>
+        /// <param name="dataBuf">Data buffer to recieve stream value.</param>
+        /// <param name="dataBufSize">Size of data buffer.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiRecordReadStream", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiRecordReadStream(uint record, int field, byte[] dataBuf, ref int dataBufSize);
+
+        /// <summary>
+        /// PInvoke of MsiRecordGetFieldCount.
+        /// </summary>
+        /// <param name="record">MSI Record handle.</param>
+        /// <returns>Count of fields in the record.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiRecordGetFieldCount", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiRecordGetFieldCount(uint record);
+
+        /// <summary>
+        /// PInvoke of MsiSetExternalUIW.
+        /// </summary>
+        /// <param name="installUIHandler">Specifies a callback function that conforms to the INSTALLUI_HANDLER specification.</param>
+        /// <param name="installLogMode">Specifies which messages to handle using the external message handler. If the external
+        /// handler returns a non-zero result, then that message will not be sent to the UI, instead the message will be logged
+        /// if logging has been enabled.</param>
+        /// <param name="context">Pointer to an application context that is passed to the callback function.
+        /// This parameter can be used for error checking.</param>
+        /// <returns>The return value is the previously set external handler, or zero (0) if there was no previously set handler.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiSetExternalUIW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern InstallUIHandler MsiSetExternalUI(InstallUIHandler installUIHandler, int installLogMode, IntPtr context);
+
+        /// <summary>
+        /// PInvoke of MsiSetInternalUI.
+        /// </summary>
+        /// <param name="uiLevel">Specifies the level of complexity of the user interface.</param>
+        /// <param name="hwnd">Pointer to a window. This window becomes the owner of any user interface created.
+        /// A pointer to the previous owner of the user interface is returned.
+        /// If this parameter is null, the owner of the user interface does not change.</param>
+        /// <returns>The previous user interface level is returned. If an invalid dwUILevel is passed, then INSTALLUILEVEL_NOCHANGE is returned.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiSetInternalUI", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiSetInternalUI(int uiLevel, ref IntPtr hwnd);
+
+        /// <summary>
+        /// PInvoke of MsiSummaryInfoGetPropertyW.
+        /// </summary>
+        /// <param name="summaryInfo">Handle to summary info.</param>
+        /// <param name="property">Property to get value from.</param>
+        /// <param name="dataType">Data type of property.</param>
+        /// <param name="integerValue">Integer to receive integer value.</param>
+        /// <param name="fileTimeValue">File time to receive file time value.</param>
+        /// <param name="stringValueBuf">String buffer to receive string value.</param>
+        /// <param name="stringValueBufSize">Size of string buffer.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiSummaryInfoGetPropertyW", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiSummaryInfoGetProperty(uint summaryInfo, int property, out uint dataType, out int integerValue, ref FILETIME fileTimeValue, StringBuilder stringValueBuf, ref int stringValueBufSize);
+
+        /// <summary>
+        /// PInvoke of MsiViewGetColumnInfo.
+        /// </summary>
+        /// <param name="view">Handle to view.</param>
+        /// <param name="columnInfo">Column info.</param>
+        /// <param name="record">Handle for returned record.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiViewGetColumnInfo", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiViewGetColumnInfo(uint view, int columnInfo, out uint record);
+
+        /// <summary>
+        /// PInvoke of MsiViewExecute.
+        /// </summary>
+        /// <param name="view">Handle of view to execute.</param>
+        /// <param name="record">Handle to a record that supplies the parameters for the view.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiViewExecute", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiViewExecute(uint view, uint record);
+
+        /// <summary>
+        /// PInvoke of MsiViewFetch.
+        /// </summary>
+        /// <param name="view">Handle of view to fetch a row from.</param>
+        /// <param name="record">Handle to receive record info.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiViewFetch", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiViewFetch(uint view, out uint record);
+
+        /// <summary>
+        /// PInvoke of MsiViewModify.
+        /// </summary>
+        /// <param name="view">Handle of view to modify.</param>
+        /// <param name="modifyMode">Modify mode.</param>
+        /// <param name="record">Handle of record.</param>
+        /// <returns>Error code.</returns>
+        [DllImport("msi.dll", EntryPoint = "MsiViewModify", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        internal static extern int MsiViewModify(uint view, int modifyMode, uint record);
+
+        /// <summary>
+        /// contains the file hash information returned by MsiGetFileHash and used in the MsiFileHash table.
+        /// </summary>
+        [StructLayout(LayoutKind.Explicit)]
+        internal class MSIFILEHASHINFO
+        {
+            [FieldOffset(0)] internal uint FileHashInfoSize;
+            [FieldOffset(4)] internal int Data0;
+            [FieldOffset(8)] internal int Data1;
+            [FieldOffset(12)]internal int Data2;
+            [FieldOffset(16)]internal int Data3;
+        }
+    }
+}
+#endif
\ No newline at end of file
diff --git a/src/WixToolset.Core/Msi/MsiException.cs b/src/WixToolset.Core/Msi/MsiException.cs
new file mode 100644
index 00000000..b33bf27a
--- /dev/null
+++ b/src/WixToolset.Core/Msi/MsiException.cs
@@ -0,0 +1,78 @@
+// 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.Msi
+{
+    using System;
+    using System.ComponentModel;
+    using WixToolset.Core.Native;
+
+    /// <summary>
+    /// Exception that wraps MsiGetLastError().
+    /// </summary>
+    [Serializable]
+    public class MsiException : Win32Exception
+    {
+        /// <summary>
+        /// Instantiate a new MsiException with a given error.
+        /// </summary>
+        /// <param name="error">The error code from the MsiXxx() function call.</param>
+        public MsiException(int error) : base(error)
+        {
+            uint handle = MsiInterop.MsiGetLastErrorRecord();
+            if (0 != handle)
+            {
+                using (Record record = new Record(handle))
+                {
+                    this.MsiError = record.GetInteger(1);
+
+                    int errorInfoCount = record.GetFieldCount() - 1;
+                    this.ErrorInfo = new string[errorInfoCount];
+                    for (int i = 0; i < errorInfoCount; ++i)
+                    {
+                        this.ErrorInfo[i] = record.GetString(i + 2);
+                    }
+                }
+            }
+            else
+            {
+                this.MsiError = 0;
+                this.ErrorInfo = new string[0];
+            }
+
+            this.Error = error;
+        }
+
+        /// <summary>
+        /// Gets the error number.
+        /// </summary>
+        public int Error { get; private set; }
+
+        /// <summary>
+        /// Gets the internal MSI error number.
+        /// </summary>
+        public int MsiError { get; private set; }
+
+        /// <summary>
+        /// Gets any additional the error information.
+        /// </summary>
+        public string[] ErrorInfo { get; private set; }
+
+        /// <summary>
+        /// Overrides Message property to return useful error message.
+        /// </summary>
+        public override string Message
+        {
+            get
+            {
+                if (0 == this.MsiError)
+                {
+                    return base.Message;
+                }
+                else
+                {
+                    return String.Format("Internal MSI failure. Win32 error: {0}, MSI error: {1}, detail: {2}", this.Error, this.MsiError, String.Join(", ", this.ErrorInfo));
+                }
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Msi/MsiHandle.cs b/src/WixToolset.Core/Msi/MsiHandle.cs
new file mode 100644
index 00000000..6d2dc984
--- /dev/null
+++ b/src/WixToolset.Core/Msi/MsiHandle.cs
@@ -0,0 +1,116 @@
+// 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.Msi
+{
+    using System;
+    using System.ComponentModel;
+    using System.Diagnostics;
+    using System.Threading;
+    using WixToolset.Core.Native;
+
+    /// <summary>
+    /// Wrapper class for MSI handle.
+    /// </summary>
+    public class MsiHandle : IDisposable
+    {
+        private bool disposed;
+        private uint handle;
+        private int owningThread;
+#if DEBUG
+        private string creationStack;
+#endif
+
+        /// <summary>
+        /// MSI handle destructor.
+        /// </summary>
+        ~MsiHandle()
+        {
+            this.Dispose(false);
+        }
+
+        /// <summary>
+        /// Gets or sets the MSI handle.
+        /// </summary>
+        /// <value>The MSI handle.</value>
+        internal uint Handle
+        {
+            get
+            {
+                if (this.disposed)
+                {
+                    throw new ObjectDisposedException("MsiHandle");
+                }
+
+                return this.handle;
+            }
+
+            set
+            {
+                if (this.disposed)
+                {
+                    throw new ObjectDisposedException("MsiHandle");
+                }
+
+                this.handle = value;
+                this.owningThread = Thread.CurrentThread.ManagedThreadId;
+#if DEBUG
+                this.creationStack = Environment.StackTrace;
+#endif
+            }
+        }
+
+        /// <summary>
+        /// Close the MSI handle.
+        /// </summary>
+        public void Close()
+        {
+            this.Dispose();
+        }
+
+        /// <summary>
+        /// Disposes the managed and unmanaged objects in this object.
+        /// </summary>
+        public void Dispose()
+        {
+            this.Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// Disposes the managed and unmanaged objects in this object.
+        /// </summary>
+        /// <param name="disposing">true to dispose the managed objects.</param>
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!this.disposed)
+            {
+                if (0 != this.handle)
+                {
+                    if (Thread.CurrentThread.ManagedThreadId == this.owningThread)
+                    {
+                        int error = MsiInterop.MsiCloseHandle(this.handle);
+                        if (0 != error)
+                        {
+                            throw new Win32Exception(error);
+                        }
+                        this.handle = 0;
+                    }
+                    else
+                    {
+                        // Don't try to close the handle on a different thread than it was opened.
+                        // This will occasionally cause MSI to AV.
+                        string message = String.Format("Leaked msi handle {0} created on thread {1} by type {2}.  This handle cannot be closed on thread {3}",
+                            this.handle, this.owningThread, this.GetType(), Thread.CurrentThread.ManagedThreadId);
+#if DEBUG
+                        throw new InvalidOperationException(String.Format("{0}.  Created {1}", message, this.creationStack));
+#else
+                        Debug.WriteLine(message);
+#endif
+                    }
+                }
+
+                this.disposed = true;
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Msi/Record.cs b/src/WixToolset.Core/Msi/Record.cs
new file mode 100644
index 00000000..438aa3b0
--- /dev/null
+++ b/src/WixToolset.Core/Msi/Record.cs
@@ -0,0 +1,182 @@
+// 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.Msi
+{
+    using System;
+    using System.ComponentModel;
+    using System.Text;
+    using WixToolset.Core.Native;
+
+    /// <summary>
+    /// Wrapper class around msi.dll interop for a record.
+    /// </summary>
+    public sealed class Record : MsiHandle
+    {
+        /// <summary>
+        /// Creates a record with the specified number of fields.
+        /// </summary>
+        /// <param name="fieldCount">Number of fields in record.</param>
+        public Record(int fieldCount)
+        {
+            this.Handle = MsiInterop.MsiCreateRecord(fieldCount);
+            if (0 == this.Handle)
+            {
+                throw new OutOfMemoryException();
+            }
+        }
+
+        /// <summary>
+        /// Creates a record from a handle.
+        /// </summary>
+        /// <param name="handle">Handle to create record from.</param>
+        internal Record(uint handle)
+        {
+            this.Handle = handle;
+        }
+
+        /// <summary>
+        /// Gets a string value at specified location.
+        /// </summary>
+        /// <param name="field">Index into record to get string.</param>
+        public string this[int field]
+        {
+            get { return this.GetString(field); }
+            set { this.SetString(field, (string)value); }
+        }
+
+        /// <summary>
+        /// Determines if the value is null at the specified location.
+        /// </summary>
+        /// <param name="field">Index into record of the field to query.</param>
+        /// <returns>true if the value is null, false otherwise.</returns>
+        public bool IsNull(int field)
+        {
+            int error = MsiInterop.MsiRecordIsNull(this.Handle, field);
+
+            switch (error)
+            {
+                case 0:
+                    return false;
+                case 1:
+                    return true;
+                default:
+                    throw new Win32Exception(error);
+            }
+        }
+
+        /// <summary>
+        /// Gets integer value at specified location.
+        /// </summary>
+        /// <param name="field">Index into record to get integer</param>
+        /// <returns>Integer value</returns>
+        public int GetInteger(int field)
+        {
+            return MsiInterop.MsiRecordGetInteger(this.Handle, field);
+        }
+
+        /// <summary>
+        /// Sets integer value at specified location.
+        /// </summary>
+        /// <param name="field">Index into record to set integer.</param>
+        /// <param name="value">Value to set into record.</param>
+        public void SetInteger(int field, int value)
+        {
+            int error = MsiInterop.MsiRecordSetInteger(this.Handle, field, value);
+            if (0 != error)
+            {
+                throw new Win32Exception(error);
+            }
+        }
+
+        /// <summary>
+        /// Gets string value at specified location.
+        /// </summary>
+        /// <param name="field">Index into record to get string.</param>
+        /// <returns>String value</returns>
+        public string GetString(int field)
+        {
+            int bufferSize = 255;
+            StringBuilder buffer = new StringBuilder(bufferSize);
+            int error = MsiInterop.MsiRecordGetString(this.Handle, field, buffer, ref bufferSize);
+            if (234 == error)
+            {
+                buffer.EnsureCapacity(++bufferSize);
+                error = MsiInterop.MsiRecordGetString(this.Handle, field, buffer, ref bufferSize);
+            }
+
+            if (0 != error)
+            {
+                throw new Win32Exception(error);
+            }
+
+            return (0 < buffer.Length ? buffer.ToString() : null);
+        }
+
+        /// <summary>
+        /// Set string value at specified location
+        /// </summary>
+        /// <param name="field">Index into record to set string.</param>
+        /// <param name="value">Value to set into record</param>
+        public void SetString(int field, string value)
+        {
+            int error = MsiInterop.MsiRecordSetString(this.Handle, field, value);
+            if (0 != error)
+            {
+                throw new Win32Exception(error);
+            }
+        }
+
+        /// <summary>
+        /// Get stream at specified location.
+        /// </summary>
+        /// <param name="field">Index into record to get stream.</param>
+        /// <param name="buffer">buffer to receive bytes from stream.</param>
+        /// <param name="requestedBufferSize">Buffer size to read.</param>
+        /// <returns>Stream read into string.</returns>
+        public int GetStream(int field, byte[] buffer, int requestedBufferSize)
+        {
+            int bufferSize = 255;
+            if (requestedBufferSize > 0)
+            {
+                bufferSize = requestedBufferSize;
+            }
+
+            int error = MsiInterop.MsiRecordReadStream(this.Handle, field, buffer, ref bufferSize);
+            if (0 != error)
+            {
+                throw new Win32Exception(error);
+            }
+
+            return bufferSize;
+        }
+
+        /// <summary>
+        /// Sets a stream at a specified location.
+        /// </summary>
+        /// <param name="field">Index into record to set stream.</param>
+        /// <param name="path">Path to file to read into stream.</param>
+        public void SetStream(int field, string path)
+        {
+            int error = MsiInterop.MsiRecordSetStream(this.Handle, field, path);
+            if (0 != error)
+            {
+                throw new Win32Exception(error);
+            }
+        }
+
+        /// <summary>
+        /// Gets the number of fields in record.
+        /// </summary>
+        /// <returns>Count of fields in record.</returns>
+        public int GetFieldCount()
+        {
+            int size = MsiInterop.MsiRecordGetFieldCount(this.Handle);
+            if (0 > size)
+            {
+                throw new Win32Exception();
+            }
+
+            return size;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Msi/Session.cs b/src/WixToolset.Core/Msi/Session.cs
new file mode 100644
index 00000000..d3a19711
--- /dev/null
+++ b/src/WixToolset.Core/Msi/Session.cs
@@ -0,0 +1,45 @@
+// 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.Msi
+{
+    using System;
+    using System.ComponentModel;
+    using System.Globalization;
+    using WixToolset.Core.Native;
+
+    /// <summary>
+    /// Controls the installation process.
+    /// </summary>
+    internal sealed class Session : MsiHandle
+    {
+        /// <summary>
+        /// Instantiate a new Session.
+        /// </summary>
+        /// <param name="database">The database to open.</param>
+        public Session(Database database)
+        {
+            string packagePath = String.Format(CultureInfo.InvariantCulture, "#{0}", (uint)database.Handle);
+
+            uint handle = 0;
+            int error = MsiInterop.MsiOpenPackage(packagePath, out handle);
+            if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+            this.Handle = handle;
+        }
+
+        /// <summary>
+        /// Executes a built-in action, custom action, or user-interface wizard action.
+        /// </summary>
+        /// <param name="action">Specifies the action to execute.</param>
+        public void DoAction(string action)
+        {
+            int error = MsiInterop.MsiDoAction(this.Handle, action);
+            if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Msi/SummaryInformation.cs b/src/WixToolset.Core/Msi/SummaryInformation.cs
new file mode 100644
index 00000000..39949db6
--- /dev/null
+++ b/src/WixToolset.Core/Msi/SummaryInformation.cs
@@ -0,0 +1,323 @@
+// 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.Msi
+{
+    using System;
+    using System.ComponentModel;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Globalization;
+    using System.Text;
+    using System.Runtime.InteropServices;
+    using FILETIME = System.Runtime.InteropServices.ComTypes.FILETIME;
+    using WixToolset.Core.Native;
+
+    /// <summary>
+    /// Summary information for the MSI files.
+    /// </summary>
+    internal sealed class SummaryInformation : MsiHandle
+    {
+        /// <summary>
+        /// Summary information properties for transforms.
+        /// </summary>
+        public enum Transform
+        {
+            /// <summary>PID_CODEPAGE = code page for the summary information stream</summary>
+            CodePage = 1,
+
+            /// <summary>PID_TITLE = typically just "Transform"</summary>
+            Title = 2,
+
+            /// <summary>PID_SUBJECT = original subject of target</summary>
+            TargetSubject = 3,
+
+            /// <summary>PID_AUTHOR = original manufacturer of target</summary>
+            TargetManufacturer = 4,
+
+            /// <summary>PID_KEYWORDS = keywords for the transform, typically including at least "Installer"</summary>
+            Keywords = 5,
+
+            /// <summary>PID_COMMENTS = describes what this package does</summary>
+            Comments = 6,
+
+            /// <summary>PID_TEMPLATE = target platform;language</summary>
+            TargetPlatformAndLanguage = 7,
+
+            /// <summary>PID_LASTAUTHOR = updated platform;language</summary>
+            UpdatedPlatformAndLanguage = 8,
+
+            /// <summary>PID_REVNUMBER = {productcode}version;{newproductcode}newversion;upgradecode</summary>
+            ProductCodes = 9,
+
+            /// <summary>PID_LASTPRINTED should be null for transforms</summary>
+            Reserved11 = 11,
+
+            ///.<summary>PID_CREATE_DTM = the timestamp when the transform was created</summary>
+            CreationTime = 12,
+
+            /// <summary>PID_PAGECOUNT = minimum installer version</summary>
+            InstallerRequirement = 14,
+
+            /// <summary>PID_CHARCOUNT = validation and error flags</summary>
+            ValidationFlags = 16,
+
+            /// <summary>PID_APPNAME = the application that created the transform</summary>
+            CreatingApplication = 18,
+
+            /// <summary>PID_SECURITY = whether read-only is enforced; should always be 4 for transforms</summary>
+            Security = 19,
+        }
+
+        /// <summary>
+        /// Summary information properties for patches.
+        /// </summary>
+        public enum Patch
+        {
+            /// <summary>PID_CODEPAGE = code page of the summary information stream</summary>
+            CodePage = 1,
+
+            /// <summary>PID_TITLE = a brief description of the package type</summary>
+            Title = 2,
+
+            /// <summary>PID_SUBJECT = package name</summary>
+            PackageName = 3,
+
+            /// <summary>PID_AUTHOR = manufacturer of the patch package</summary>
+            Manufacturer = 4,
+
+            /// <summary>PID_KEYWORDS = alternate sources for the patch package</summary>
+            Sources = 5,
+
+            /// <summary>PID_COMMENTS = general purpose of the patch package</summary>
+            Comments = 6,
+
+            /// <summary>PID_TEMPLATE = semicolon delimited list of ProductCodes</summary>
+            ProductCodes = 7,
+
+            /// <summary>PID_LASTAUTHOR = semicolon delimited list of transform names</summary>
+            TransformNames = 8,
+
+            /// <summary>PID_REVNUMBER = GUID patch code</summary>
+            PatchCode = 9,
+
+            /// <summary>PID_LASTPRINTED should be null for patches</summary>
+            Reserved11 = 11,
+
+            /// <summary>PID_PAGECOUNT should be null for patches</summary>
+            Reserved14 = 14,
+
+            /// <summary>PID_WORDCOUNT = minimum installer version</summary>
+            InstallerRequirement = 15,
+
+            /// <summary>PID_CHARCOUNT should be null for patches</summary>
+            Reserved16 = 16,
+
+            /// <summary>PID_SECURITY = read-only attribute of the patch package</summary>
+            Security = 19,
+        }
+
+        /// <summary>
+        /// Summary information values for the InstallerRequirement property.
+        /// </summary>
+        public enum InstallerRequirement
+        {
+            /// <summary>Any version of the installer will do</summary>
+            Version10 = 1,
+
+            /// <summary>At least 1.2</summary>
+            Version12 = 2,
+
+            /// <summary>At least 2.0</summary>
+            Version20 = 3,
+
+            /// <summary>At least 3.0</summary>
+            Version30 = 4,
+
+            /// <summary>At least 3.1</summary>
+            Version31 = 5,
+        }
+
+        /// <summary>
+        /// Instantiate a new SummaryInformation class from an open database.
+        /// </summary>
+        /// <param name="db">Database to retrieve summary information from.</param>
+        public SummaryInformation(Database db)
+        {
+            if (null == db)
+            {
+                throw new ArgumentNullException("db");
+            }
+
+            uint handle = 0;
+            int error = MsiInterop.MsiGetSummaryInformation(db.Handle, null, 0, ref handle);
+            if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+            this.Handle = handle;
+        }
+
+        /// <summary>
+        /// Instantiate a new SummaryInformation class from a database file.
+        /// </summary>
+        /// <param name="databaseFile">The database file.</param>
+        public SummaryInformation(string databaseFile)
+        {
+            if (null == databaseFile)
+            {
+                throw new ArgumentNullException("databaseFile");
+            }
+
+            uint handle = 0;
+            int error = MsiInterop.MsiGetSummaryInformation(0, databaseFile, 0, ref handle);
+            if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+            this.Handle = handle;
+        }
+
+        /// <summary>
+        /// Variant types in the summary information table.
+        /// </summary>
+        private enum VT : uint
+        {
+            /// <summary>Variant has not been assigned.</summary>
+            EMPTY = 0,
+
+            /// <summary>Null variant type.</summary>
+            NULL = 1,
+
+            /// <summary>16-bit integer variant type.</summary>
+            I2 = 2,
+
+            /// <summary>32-bit integer variant type.</summary>
+            I4 = 3,
+
+            /// <summary>String variant type.</summary>
+            LPSTR = 30,
+
+            /// <summary>Date time (FILETIME, converted to Variant time) variant type.</summary>
+            FILETIME = 64,
+        }
+
+        /// <summary>
+        /// Gets a summary information property.
+        /// </summary>
+        /// <param name="index">Index of the summary information property.</param>
+        /// <returns>The summary information property.</returns>
+        public string GetProperty(int index)
+        {
+            uint dataType;
+            StringBuilder stringValue = new StringBuilder("");
+            int bufSize = 0;
+            int intValue;
+            FILETIME timeValue;
+            timeValue.dwHighDateTime = 0;
+            timeValue.dwLowDateTime = 0;
+
+            int error = MsiInterop.MsiSummaryInfoGetProperty(this.Handle, index, out dataType, out intValue, ref timeValue, stringValue, ref bufSize);
+            if (234 == error)
+            {
+                stringValue.EnsureCapacity(++bufSize);
+                error = MsiInterop.MsiSummaryInfoGetProperty(this.Handle, index, out dataType, out intValue, ref timeValue, stringValue, ref bufSize);
+            }
+
+            if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+
+            switch ((VT)dataType)
+            {
+                case VT.EMPTY:
+                    return String.Empty;
+                case VT.LPSTR:
+                    return stringValue.ToString();
+                case VT.I2:
+                case VT.I4:
+                    return Convert.ToString(intValue, CultureInfo.InvariantCulture);
+                case VT.FILETIME:
+                    long longFileTime = (((long)timeValue.dwHighDateTime) << 32) | unchecked((uint)timeValue.dwLowDateTime);
+                    DateTime dateTime = DateTime.FromFileTime(longFileTime);
+                    return dateTime.ToString("yyyy/MM/dd HH:mm:ss", CultureInfo.InvariantCulture);
+                default:
+                    throw new InvalidOperationException();
+            }
+        }
+    }
+
+    /// <summary>
+    /// Summary information values for the CharCount property in transforms.
+    /// </summary>
+    [Flags]
+    [SuppressMessage("Microsoft.Naming", "CA1711:IdentifiersShouldNotHaveIncorrectSuffix")]
+    public enum TransformFlags
+    {
+        /// <summary>Ignore error when adding a row that exists.</summary>
+        ErrorAddExistingRow = 0x1,
+
+        /// <summary>Ignore error when deleting a row that does not exist.</summary>
+        ErrorDeleteMissingRow = 0x2,
+
+        /// <summary>Ignore error when adding a table that exists. </summary>
+        ErrorAddExistingTable = 0x4,
+
+        /// <summary>Ignore error when deleting a table that does not exist. </summary>
+        ErrorDeleteMissingTable = 0x8,
+
+        /// <summary>Ignore error when updating a row that does not exist. </summary>
+        ErrorUpdateMissingRow = 0x10,
+
+        /// <summary>Ignore error when transform and database code pages do not match, and their code pages are neutral.</summary>
+        ErrorChangeCodePage = 0x20,
+
+        /// <summary>Default language must match base database. </summary>
+        ValidateLanguage = 0x10000,
+
+        /// <summary>Product must match base database.</summary>
+        ValidateProduct = 0x20000,
+
+        /// <summary>Check major version only. </summary>
+        ValidateMajorVersion = 0x80000,
+
+        /// <summary>Check major and minor versions only. </summary>
+        ValidateMinorVersion = 0x100000,
+
+        /// <summary>Check major, minor, and update versions.</summary>
+        ValidateUpdateVersion = 0x200000,
+
+        /// <summary>Installed version lt base version. </summary>
+        ValidateNewLessBaseVersion = 0x400000,
+
+        /// <summary>Installed version lte base version. </summary>
+        ValidateNewLessEqualBaseVersion = 0x800000,
+
+        /// <summary>Installed version eq base version. </summary>
+        ValidateNewEqualBaseVersion = 0x1000000,
+
+        /// <summary>Installed version gte base version.</summary>
+        ValidateNewGreaterEqualBaseVersion = 0x2000000,
+
+        /// <summary>Installed version gt base version.</summary>
+        ValidateNewGreaterBaseVersion = 0x4000000,
+
+        /// <summary>UpgradeCode must match base database.</summary>
+        ValidateUpgradeCode = 0x8000000,
+
+        /// <summary>Masks all version checks on ProductVersion.</summary>
+        ProductVersionMask = ValidateMajorVersion | ValidateMinorVersion | ValidateUpdateVersion,
+
+        /// <summary>Masks all operations on ProductVersion.</summary>
+        ProductVersionOperatorMask = ValidateNewLessBaseVersion | ValidateNewLessEqualBaseVersion | ValidateNewEqualBaseVersion | ValidateNewGreaterEqualBaseVersion | ValidateNewGreaterBaseVersion,
+
+        /// <summary>Default value for instance transforms.</summary>
+        InstanceTransformDefault = ErrorAddExistingRow | ErrorDeleteMissingRow | ErrorAddExistingTable | ErrorDeleteMissingTable | ErrorUpdateMissingRow | ErrorChangeCodePage | ValidateProduct | ValidateUpdateVersion | ValidateNewGreaterEqualBaseVersion,
+
+        /// <summary>Default value for language transforms.</summary>
+        LanguageTransformDefault = ErrorAddExistingRow | ErrorDeleteMissingRow | ErrorAddExistingTable | ErrorDeleteMissingTable | ErrorUpdateMissingRow | ErrorChangeCodePage | ValidateProduct,
+
+        /// <summary>Default value for patch transforms.</summary>
+        PatchTransformDefault = ErrorAddExistingRow | ErrorDeleteMissingRow | ErrorAddExistingTable | ErrorDeleteMissingTable | ErrorUpdateMissingRow | ValidateProduct | ValidateUpdateVersion | ValidateNewEqualBaseVersion | ValidateUpgradeCode,
+    }
+
+}
diff --git a/src/WixToolset.Core/Msi/View.cs b/src/WixToolset.Core/Msi/View.cs
new file mode 100644
index 00000000..d6542824
--- /dev/null
+++ b/src/WixToolset.Core/Msi/View.cs
@@ -0,0 +1,189 @@
+// 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.Msi
+{
+    using System;
+    using System.ComponentModel;
+    using System.Globalization;
+    using WixToolset.Core.Native;
+
+    /// <summary>
+    /// Enumeration of different modify modes.
+    /// </summary>
+    public enum ModifyView
+    {
+        /// <summary>
+        /// Writes current data in the cursor to a table row. Updates record if the primary 
+        /// keys match an existing row and inserts if they do not match. Fails with a read-only 
+        /// database. This mode cannot be used with a view containing joins.
+        /// </summary>
+        Assign = MsiInterop.MSIMODIFYASSIGN,
+
+        /// <summary>
+        /// Remove a row from the table. You must first call the Fetch function with the same
+        /// record. Fails if the row has been deleted. Works only with read-write records. This
+        /// mode cannot be used with a view containing joins.
+        /// </summary>
+        Delete = MsiInterop.MSIMODIFYDELETE,
+
+        /// <summary>
+        /// Inserts a record. Fails if a row with the same primary keys exists. Fails with a read-only
+        /// database. This mode cannot be used with a view containing joins.
+        /// </summary>
+        Insert = MsiInterop.MSIMODIFYINSERT,
+
+        /// <summary>
+        /// Inserts a temporary record. The information is not persistent. Fails if a row with the 
+        /// same primary key exists. Works only with read-write records. This mode cannot be 
+        /// used with a view containing joins.
+        /// </summary>
+        InsertTemporary = MsiInterop.MSIMODIFYINSERTTEMPORARY,
+
+        /// <summary>
+        /// Inserts or validates a record in a table. Inserts if primary keys do not match any row
+        /// and validates if there is a match. Fails if the record does not match the data in
+        /// the table. Fails if there is a record with a duplicate key that is not identical.
+        /// Works only with read-write records. This mode cannot be used with a view containing joins.
+        /// </summary>
+        Merge = MsiInterop.MSIMODIFYMERGE,
+
+        /// <summary>
+        /// Refreshes the information in the record. Must first call Fetch with the
+        /// same record. Fails for a deleted row. Works with read-write and read-only records.
+        /// </summary>
+        Refresh = MsiInterop.MSIMODIFYREFRESH,
+
+        /// <summary>
+        /// Updates or deletes and inserts a record into a table. Must first call Fetch with
+        /// the same record. Updates record if the primary keys are unchanged. Deletes old row and
+        /// inserts new if primary keys have changed. Fails with a read-only database. This mode cannot
+        /// be used with a view containing joins.
+        /// </summary>
+        Replace = MsiInterop.MSIMODIFYREPLACE,
+
+        /// <summary>
+        /// Refreshes the information in the supplied record without changing the position in the
+        /// result set and without affecting subsequent fetch operations. The record may then
+        /// be used for subsequent Update, Delete, and Refresh. All primary key columns of the
+        /// table must be in the query and the record must have at least as many fields as the
+        /// query. Seek cannot be used with multi-table queries. This mode cannot be used with
+        /// a view containing joins. See also the remarks.
+        /// </summary>
+        Seek = MsiInterop.MSIMODIFYSEEK,
+
+        /// <summary>
+        /// Updates an existing record. Non-primary keys only. Must first call Fetch. Fails with a
+        /// deleted record. Works only with read-write records.
+        /// </summary>
+        Update = MsiInterop.MSIMODIFYUPDATE
+    }
+
+    /// <summary>
+    /// Wrapper class for MSI API views.
+    /// </summary>
+    internal sealed class View : MsiHandle
+    {
+        /// <summary>
+        /// Constructor that creates a view given a database handle and a query.
+        /// </summary>
+        /// <param name="db">Handle to the database to run the query on.</param>
+        /// <param name="query">Query to be executed.</param>
+        public View(Database db, string query)
+        {
+            if (null == db)
+            {
+                throw new ArgumentNullException("db");
+            }
+
+            if (null == query)
+            {
+                throw new ArgumentNullException("query");
+            }
+
+            uint handle = 0;
+
+            int error = MsiInterop.MsiDatabaseOpenView(db.Handle, query, out handle);
+            if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+
+            this.Handle = handle;
+        }
+
+        /// <summary>
+        /// Executes a view with no customizable parameters.
+        /// </summary>
+        public void Execute()
+        {
+            this.Execute(null);
+        }
+
+        /// <summary>
+        /// Executes a query substituing the values from the records into the customizable parameters 
+        /// in the view.
+        /// </summary>
+        /// <param name="record">Record containing parameters to be substituded into the view.</param>
+        public void Execute(Record record)
+        {
+            int error = MsiInterop.MsiViewExecute(this.Handle, null == record ? 0 : record.Handle);
+            if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+        }
+
+        /// <summary>
+        /// Fetches the next row in the view.
+        /// </summary>
+        /// <returns>Returns the fetched record; otherwise null.</returns>
+        public Record Fetch()
+        {
+            uint recordHandle;
+
+            int error = MsiInterop.MsiViewFetch(this.Handle, out recordHandle);
+            if (259 == error)
+            {
+                return null;
+            }
+            else if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+
+            return new Record(recordHandle);
+        }
+
+        /// <summary>
+        /// Updates a fetched record.
+        /// </summary>
+        /// <param name="type">Type of modification mode.</param>
+        /// <param name="record">Record to be modified.</param>
+        public void Modify(ModifyView type, Record record)
+        {
+            int error = MsiInterop.MsiViewModify(this.Handle, Convert.ToInt32(type, CultureInfo.InvariantCulture), record.Handle);
+            if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+        }
+
+        /// <summary>
+        /// Returns a record containing column names or definitions.
+        /// </summary>
+        /// <param name="columnType">Specifies a flag indicating what type of information is needed. Either MSICOLINFO_NAMES or MSICOLINFO_TYPES.</param>
+        /// <returns>The record containing information about the column.</returns>
+        public Record GetColumnInfo(int columnType)
+        {
+            uint recordHandle;
+
+            int error = MsiInterop.MsiViewGetColumnInfo(this.Handle, columnType, out recordHandle);
+            if (0 != error)
+            {
+                throw new MsiException(error);
+            }
+
+            return new Record(recordHandle);
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Mutator.cs b/src/WixToolset.Core/Mutator.cs
new file mode 100644
index 00000000..d37815f4
--- /dev/null
+++ b/src/WixToolset.Core/Mutator.cs
@@ -0,0 +1,115 @@
+// 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
+{
+    using System;
+    using System.Collections;
+    using WixToolset.Extensibility;
+    using Wix = WixToolset.Data.Serialize;
+
+    /// <summary>
+    /// The WiX Toolset mutator.
+    /// </summary>
+    public sealed class Mutator
+    {
+        private SortedList extensions;
+        private string extensionArgument;
+
+        /// <summary>
+        /// Instantiate a new mutator.
+        /// </summary>
+        public Mutator()
+        {
+            this.extensions = new SortedList();
+        }
+
+        /// <summary>
+        /// Gets or sets the harvester core for the extension.
+        /// </summary>
+        /// <value>The harvester core for the extension.</value>
+        public IHarvesterCore Core { get; set; }
+
+        /// <summary>
+        /// Gets or sets the value of the extension argument passed to heat.
+        /// </summary>
+        /// <value>The extension argument.</value>
+        public string ExtensionArgument
+        {
+            get { return this.extensionArgument; }
+            set { this.extensionArgument = value; }
+        }
+
+        /// <summary>
+        /// Adds a mutator extension.
+        /// </summary>
+        /// <param name="mutatorExtension">The mutator extension to add.</param>
+        public void AddExtension(MutatorExtension mutatorExtension)
+        {
+            this.extensions.Add(mutatorExtension.Sequence, mutatorExtension);
+        }
+
+        /// <summary>
+        /// Mutate a WiX document.
+        /// </summary>
+        /// <param name="wix">The Wix document element.</param>
+        /// <returns>true if mutation was successful</returns>
+        public bool Mutate(Wix.Wix wix)
+        {
+            bool encounteredError = false;
+            
+            try
+            {
+                foreach (MutatorExtension mutatorExtension in this.extensions.Values)
+                {
+                    if (null == mutatorExtension.Core)
+                    {
+                        mutatorExtension.Core = this.Core;
+                    }
+
+                    mutatorExtension.Mutate(wix);
+                }
+            }
+            finally
+            {
+                encounteredError = this.Core.EncounteredError;
+            }
+
+            // return the Wix document element only if mutation completed successfully
+            return !encounteredError;
+        }
+
+        /// <summary>
+        /// Mutate a WiX document.
+        /// </summary>
+        /// <param name="wixString">The Wix document as a string.</param>
+        /// <returns>The mutated Wix document as a string if mutation was successful, else null.</returns>
+        public string Mutate(string wixString)
+        {
+            bool encounteredError = false;
+
+            try
+            {
+                foreach (MutatorExtension mutatorExtension in this.extensions.Values)
+                {
+                    if (null == mutatorExtension.Core)
+                    {
+                        mutatorExtension.Core = this.Core;
+                    }
+
+                    wixString = mutatorExtension.Mutate(wixString);
+
+                    if (String.IsNullOrEmpty(wixString) || this.Core.EncounteredError)
+                    {
+                        break;
+                    }
+                }
+            }
+            finally
+            {
+                encounteredError = this.Core.EncounteredError;
+            }
+
+            return encounteredError ? null : wixString;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Ole32/Storage.cs b/src/WixToolset.Core/Ole32/Storage.cs
new file mode 100644
index 00000000..c6a43bc4
--- /dev/null
+++ b/src/WixToolset.Core/Ole32/Storage.cs
@@ -0,0 +1,437 @@
+// 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.Ole32
+{
+    using System;
+    using System.Runtime.InteropServices;
+    using FILETIME = System.Runtime.InteropServices.ComTypes.FILETIME;
+    using STATSTG = System.Runtime.InteropServices.ComTypes.STATSTG;
+
+    /// <summary>
+    /// Specifies the access mode to use when opening, creating, or deleting a storage object.
+    /// </summary>
+    internal enum StorageMode
+    {
+        /// <summary>
+        /// Indicates that the object is read-only, meaning that modifications cannot be made.
+        /// </summary>
+        Read = 0x0,
+
+        /// <summary>
+        /// Enables you to save changes to the object, but does not permit access to its data.
+        /// </summary>
+        Write = 0x1,
+
+        /// <summary>
+        /// Enables access and modification of object data.
+        /// </summary>
+        ReadWrite = 0x2,
+
+        /// <summary>
+        /// Specifies that subsequent openings of the object are not denied read or write access.
+        /// </summary>
+        ShareDenyNone = 0x40,
+
+        /// <summary>
+        /// Prevents others from subsequently opening the object in Read mode.
+        /// </summary>
+        ShareDenyRead = 0x30,
+
+        /// <summary>
+        /// Prevents others from subsequently opening the object for Write or ReadWrite access.
+        /// </summary>
+        ShareDenyWrite = 0x20,
+
+        /// <summary>
+        /// Prevents others from subsequently opening the object in any mode.
+        /// </summary>
+        ShareExclusive = 0x10,
+
+        /// <summary>
+        /// Opens the storage object with exclusive access to the most recently committed version.
+        /// </summary>
+        Priority = 0x40000,
+
+        /// <summary>
+        /// Indicates that an existing storage object or stream should be removed before the new object replaces it.
+        /// </summary>
+        Create = 0x1000,
+    }
+
+    /// <summary>
+    /// Wrapper for the compound storage file APIs.
+    /// </summary>
+    internal sealed class Storage : IDisposable
+    {
+        private bool disposed;
+        private IStorage storage;
+
+        /// <summary>
+        /// Instantiate a new Storage.
+        /// </summary>
+        /// <param name="storage">The native storage interface.</param>
+        private Storage(IStorage storage)
+        {
+            this.storage = storage;
+        }
+
+        /// <summary>
+        /// Storage destructor.
+        /// </summary>
+        ~Storage()
+        {
+            this.Dispose();
+        }
+
+        /// <summary>
+        /// The IEnumSTATSTG interface enumerates an array of STATSTG structures.
+        /// </summary>
+        [ComImport, Guid("0000000d-0000-0000-C000-000000000046"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+        public interface IEnumSTATSTG
+        {
+            /// <summary>
+            /// Gets a specified number of STATSTG structures.
+            /// </summary>
+            /// <param name="celt">The number of STATSTG structures requested.</param>
+            /// <param name="rgelt">An array of STATSTG structures returned.</param>
+            /// <param name="pceltFetched">The number of STATSTG structures retrieved in the rgelt parameter.</param>
+            /// <returns>The error code.</returns>
+            [PreserveSig]
+            uint Next(uint celt, [MarshalAs(UnmanagedType.LPArray), Out] STATSTG[] rgelt, out uint pceltFetched);
+
+            /// <summary>
+            /// Skips a specified number of STATSTG structures in the enumeration sequence.
+            /// </summary>
+            /// <param name="celt">The number of STATSTG structures to skip.</param>
+            void Skip(uint celt);
+
+            /// <summary>
+            /// Resets the enumeration sequence to the beginning of the STATSTG structure array.
+            /// </summary>
+            void Reset();
+
+            /// <summary>
+            /// Creates a new enumerator that contains the same enumeration state as the current STATSTG structure enumerator.
+            /// </summary>
+            /// <returns>The cloned IEnumSTATSTG interface.</returns>
+            [return: MarshalAs(UnmanagedType.Interface)]
+            IEnumSTATSTG Clone();
+        }
+
+        /// <summary>
+        /// The IStorage interface supports the creation and management of structured storage objects.
+        /// </summary>
+        [ComImport, Guid("0000000b-0000-0000-C000-000000000046"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+        private interface IStorage
+        {
+            /// <summary>
+            /// Creates and opens a stream object with the specified name contained in this storage object.
+            /// </summary>
+            /// <param name="pwcsName">The name of the newly created stream.</param>
+            /// <param name="grfMode">Specifies the access mode to use when opening the newly created stream.</param>
+            /// <param name="reserved1">Reserved for future use; must be zero.</param>
+            /// <param name="reserved2">Reserved for future use; must be zero.</param>
+            /// <param name="ppstm">On return, pointer to the location of the new IStream interface pointer.</param>
+            void CreateStream(string pwcsName, uint grfMode, uint reserved1, uint reserved2, out IStream ppstm);
+
+            /// <summary>
+            /// Opens an existing stream object within this storage object using the specified access permissions in grfMode.
+            /// </summary>
+            /// <param name="pwcsName">The name of the stream to open.</param>
+            /// <param name="reserved1">Reserved for future use; must be NULL.</param>
+            /// <param name="grfMode">Specifies the access mode to be assigned to the open stream.</param>
+            /// <param name="reserved2">Reserved for future use; must be zero.</param>
+            /// <param name="ppstm">A pointer to IStream pointer variable that receives the interface pointer to the newly opened stream object.</param>
+            void OpenStream(string pwcsName, IntPtr reserved1, uint grfMode, uint reserved2, out IStream ppstm);
+
+            /// <summary>
+            /// Creates and opens a new storage object nested within this storage object with the specified name in the specified access mode.
+            /// </summary>
+            /// <param name="pwcsName">The name of the newly created storage object.</param>
+            /// <param name="grfMode">A value that specifies the access mode to use when opening the newly created storage object.</param>
+            /// <param name="reserved1">Reserved for future use; must be zero.</param>
+            /// <param name="reserved2">Reserved for future use; must be zero.</param>
+            /// <param name="ppstg">A pointer, when successful, to the location of the IStorage pointer to the newly created storage object.</param>
+            void CreateStorage(string pwcsName, uint grfMode, uint reserved1, uint reserved2, out IStorage ppstg);
+
+            /// <summary>
+            /// Opens an existing storage object with the specified name in the specified access mode.
+            /// </summary>
+            /// <param name="pwcsName">The name of the storage object to open.</param>
+            /// <param name="pstgPriority">Must be NULL.</param>
+            /// <param name="grfMode">Specifies the access mode to use when opening the storage object.</param>
+            /// <param name="snbExclude">Must be NULL.</param>
+            /// <param name="reserved">Reserved for future use; must be zero.</param>
+            /// <param name="ppstg">When successful, pointer to the location of an IStorage pointer to the opened storage object.</param>
+            void OpenStorage(string pwcsName, IStorage pstgPriority, uint grfMode, IntPtr snbExclude, uint reserved, out IStorage ppstg);
+
+            /// <summary>
+            /// Copies the entire contents of an open storage object to another storage object.
+            /// </summary>
+            /// <param name="ciidExclude">The number of elements in the array pointed to by rgiidExclude.</param>
+            /// <param name="rgiidExclude">An array of interface identifiers (IIDs) that either the caller knows about and does not want
+            /// copied or that the storage object does not support, but whose state the caller will later explicitly copy.</param>
+            /// <param name="snbExclude">A string name block (refer to SNB) that specifies a block of storage or stream objects that are not to be copied to the destination.</param>
+            /// <param name="pstgDest">A pointer to the open storage object into which this storage object is to be copied.</param>
+            void CopyTo(uint ciidExclude, IntPtr rgiidExclude, IntPtr snbExclude, IStorage pstgDest);
+
+            /// <summary>
+            /// Copies or moves a substorage or stream from this storage object to another storage object.
+            /// </summary>
+            /// <param name="pwcsName">The name of the element in this storage object to be moved or copied.</param>
+            /// <param name="pstgDest">IStorage pointer to the destination storage object.</param>
+            /// <param name="pwcsNewName">The new name for the element in its new storage object.</param>
+            /// <param name="grfFlags">Specifies whether the operation should be a move (STGMOVE_MOVE) or a copy (STGMOVE_COPY).</param>
+            void MoveElementTo(string pwcsName, IStorage pstgDest, string pwcsNewName, uint grfFlags);
+
+            /// <summary>
+            /// Reflects changes for a transacted storage object to the parent level.
+            /// </summary>
+            /// <param name="grfCommitFlags">Controls how the changes are committed to the storage object.</param>
+            void Commit(uint grfCommitFlags);
+
+            /// <summary>
+            /// Discards all changes that have been made to the storage object since the last commit operation.
+            /// </summary>
+            void Revert();
+
+            /// <summary>
+            /// Returns an enumerator object that can be used to enumerate the storage and stream objects contained within this storage object.
+            /// </summary>
+            /// <param name="reserved1">Reserved for future use; must be zero.</param>
+            /// <param name="reserved2">Reserved for future use; must be NULL.</param>
+            /// <param name="reserved3">Reserved for future use; must be zero.</param>
+            /// <param name="ppenum">Pointer to IEnumSTATSTG* pointer variable that receives the interface pointer to the new enumerator object.</param>
+            void EnumElements(uint reserved1, IntPtr reserved2, uint reserved3, out IEnumSTATSTG ppenum);
+
+            /// <summary>
+            /// Removes the specified storage or stream from this storage object.
+            /// </summary>
+            /// <param name="pwcsName">The name of the storage or stream to be removed.</param>
+            void DestroyElement(string pwcsName);
+
+            /// <summary>
+            /// Renames the specified storage or stream in this storage object.
+            /// </summary>
+            /// <param name="pwcsOldName">The name of the substorage or stream to be changed.</param>
+            /// <param name="pwcsNewName">The new name for the specified substorage or stream.</param>
+            void RenameElement(string pwcsOldName, string pwcsNewName);
+
+            /// <summary>
+            /// Sets the modification, access, and creation times of the indicated storage element, if supported by the underlying file system.
+            /// </summary>
+            /// <param name="pwcsName">The name of the storage object element whose times are to be modified.</param>
+            /// <param name="pctime">Either the new creation time for the element or NULL if the creation time is not to be modified.</param>
+            /// <param name="patime">Either the new access time for the element or NULL if the access time is not to be modified.</param>
+            /// <param name="pmtime">Either the new modification time for the element or NULL if the modification time is not to be modified.</param>
+            void SetElementTimes(string pwcsName, FILETIME pctime, FILETIME patime, FILETIME pmtime);
+
+            /// <summary>
+            /// Assigns the specified CLSID to this storage object.
+            /// </summary>
+            /// <param name="clsid">The CLSID that is to be associated with the storage object.</param>
+            void SetClass(Guid clsid);
+
+            /// <summary>
+            /// Stores up to 32 bits of state information in this storage object.
+            /// </summary>
+            /// <param name="grfStateBits">Specifies the new values of the bits to set.</param>
+            /// <param name="grfMask">A binary mask indicating which bits in grfStateBits are significant in this call.</param>
+            void SetStateBits(uint grfStateBits, uint grfMask);
+
+            /// <summary>
+            /// Returns the STATSTG structure for this open storage object.
+            /// </summary>
+            /// <param name="pstatstg">On return, pointer to a STATSTG structure where this method places information about the open storage object.</param>
+            /// <param name="grfStatFlag">Specifies that some of the members in the STATSTG structure are not returned, thus saving a memory allocation operation.</param>
+            void Stat(out STATSTG pstatstg, uint grfStatFlag);
+        }
+
+        /// <summary>
+        /// The IStream interface lets you read and write data to stream objects.
+        /// </summary>
+        [ComImport, Guid("0000000c-0000-0000-C000-000000000046"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]
+        private interface IStream
+        {
+            /// <summary>
+            /// Reads a specified number of bytes from the stream object into memory starting at the current seek pointer.
+            /// </summary>
+            /// <param name="pv">A pointer to the buffer which the stream data is read into.</param>
+            /// <param name="cb">The number of bytes of data to read from the stream object.</param>
+            /// <param name="pcbRead">A pointer to a ULONG variable that receives the actual number of bytes read from the stream object.</param>
+            void Read([Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] byte[] pv, int cb, IntPtr pcbRead);
+
+            /// <summary>
+            /// Writes a specified number of bytes into the stream object starting at the current seek pointer.
+            /// </summary>
+            /// <param name="pv">A pointer to the buffer that contains the data that is to be written to the stream.</param>
+            /// <param name="cb">The number of bytes of data to attempt to write into the stream.</param>
+            /// <param name="pcbWritten">A pointer to a ULONG variable where this method writes the actual number of bytes written to the stream object.</param>
+            void Write([MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)] byte[] pv, int cb, IntPtr pcbWritten);
+
+            /// <summary>
+            /// Changes the seek pointer to a new location relative to the beginning of the stream, the end of the stream, or the current seek pointer.
+            /// </summary>
+            /// <param name="dlibMove">The displacement to be added to the location indicated by the dwOrigin parameter.</param>
+            /// <param name="dwOrigin">The origin for the displacement specified in dlibMove.</param>
+            /// <param name="plibNewPosition">A pointer to the location where this method writes the value of the new seek pointer from the beginning of the stream.</param>
+            void Seek(long dlibMove, int dwOrigin, IntPtr plibNewPosition);
+
+            /// <summary>
+            /// Changes the size of the stream object.
+            /// </summary>
+            /// <param name="libNewSize">Specifies the new size of the stream as a number of bytes.</param>
+            void SetSize(long libNewSize);
+
+            /// <summary>
+            /// Copies a specified number of bytes from the current seek pointer in the stream to the current seek pointer in another stream.
+            /// </summary>
+            /// <param name="pstm">A pointer to the destination stream.</param>
+            /// <param name="cb">The number of bytes to copy from the source stream.</param>
+            /// <param name="pcbRead">A pointer to the location where this method writes the actual number of bytes read from the source.</param>
+            /// <param name="pcbWritten">A pointer to the location where this method writes the actual number of bytes written to the destination.</param>
+            void CopyTo(IStream pstm, long cb, IntPtr pcbRead, IntPtr pcbWritten);
+
+            /// <summary>
+            /// Ensures that any changes made to a stream object open in transacted mode are reflected in the parent storage object.
+            /// </summary>
+            /// <param name="grfCommitFlags">Controls how the changes for the stream object are committed.</param>
+            void Commit(int grfCommitFlags);
+
+            /// <summary>
+            /// Discards all changes that have been made to a transacted stream since the last call to IStream::Commit.
+            /// </summary>
+            void Revert();
+
+            /// <summary>
+            /// Restricts access to a specified range of bytes in the stream.
+            /// </summary>
+            /// <param name="libOffset">Integer that specifies the byte offset for the beginning of the range.</param>
+            /// <param name="cb">Integer that specifies the length of the range, in bytes, to be restricted.</param>
+            /// <param name="dwLockType">Specifies the restrictions being requested on accessing the range.</param>
+            void LockRegion(long libOffset, long cb, int dwLockType);
+
+            /// <summary>
+            /// Removes the access restriction on a range of bytes previously restricted with IStream::LockRegion.
+            /// </summary>
+            /// <param name="libOffset">Specifies the byte offset for the beginning of the range.</param>
+            /// <param name="cb">Specifies, in bytes, the length of the range to be restricted.</param>
+            /// <param name="dwLockType">Specifies the access restrictions previously placed on the range.</param>
+            void UnlockRegion(long libOffset, long cb, int dwLockType);
+
+            /// <summary>
+            /// Retrieves the STATSTG structure for this stream.
+            /// </summary>
+            /// <param name="pstatstg">Pointer to a STATSTG structure where this method places information about this stream object.</param>
+            /// <param name="grfStatFlag">Specifies that this method does not return some of the members in the STATSTG structure, thus saving a memory allocation operation.</param>
+            void Stat(out STATSTG pstatstg, int grfStatFlag);
+
+            /// <summary>
+            /// Creates a new stream object that references the same bytes as the original stream but provides a separate seek pointer to those bytes.
+            /// </summary>
+            /// <param name="ppstm">When successful, pointer to the location of an IStream pointer to the new stream object.</param>
+            void Clone(out IStream ppstm);
+        }
+
+        /// <summary>
+        /// Creates a new compound file storage object.
+        /// </summary>
+        /// <param name="storageFile">The compound file being created.</param>
+        /// <param name="mode">Specifies the access mode to use when opening the new storage object.</param>
+        /// <returns>The created Storage object.</returns>
+        public static Storage CreateDocFile(string storageFile, StorageMode mode)
+        {
+            IStorage storage = NativeMethods.StgCreateDocfile(storageFile, (uint)mode, 0);
+
+            return new Storage(storage);
+        }
+
+        /// <summary>
+        /// Opens an existing root storage object in the file system.
+        /// </summary>
+        /// <param name="storageFile">The file that contains the storage object to open.</param>
+        /// <param name="mode">Specifies the access mode to use to open the storage object.</param>
+        /// <returns>The created Storage object.</returns>
+        public static Storage Open(string storageFile, StorageMode mode)
+        {
+            IStorage storage = NativeMethods.StgOpenStorage(storageFile, IntPtr.Zero, (uint)mode, IntPtr.Zero, 0);
+
+            return new Storage(storage);
+        }
+
+        /// <summary>
+        /// Copies the entire contents of this open storage object into another Storage object.
+        /// </summary>
+        /// <param name="destinationStorage">The destination Storage object.</param>
+        public void CopyTo(Storage destinationStorage)
+        {
+            this.storage.CopyTo(0, IntPtr.Zero, IntPtr.Zero, destinationStorage.storage);
+        }
+
+        /// <summary>
+        /// Opens an existing Storage object with the specified name according to the specified access mode.
+        /// </summary>
+        /// <param name="name">The name of the Storage object.</param>
+        /// <returns>The opened Storage object.</returns>
+        public Storage OpenStorage(string name)
+        {
+            IStorage subStorage;
+
+            this.storage.OpenStorage(name, null, (uint)(StorageMode.Read | StorageMode.ShareExclusive), IntPtr.Zero, 0, out subStorage);
+
+            return new Storage(subStorage);
+        }
+
+        /// <summary>
+        /// Disposes the managed and unmanaged objects in this object.
+        /// </summary>
+        public void Dispose()
+        {
+            if (!this.disposed)
+            {
+                Marshal.ReleaseComObject(this.storage);
+
+                this.disposed = true;
+            }
+
+            GC.SuppressFinalize(this);
+        }
+
+        /// <summary>
+        /// The native methods.
+        /// </summary>
+        private sealed class NativeMethods
+        {
+            /// <summary>
+            /// Protect the constructor since this class only contains static methods.
+            /// </summary>
+            private NativeMethods()
+            {
+            }
+
+            /// <summary>
+            /// Creates a new compound file storage object.
+            /// </summary>
+            /// <param name="pwcsName">The name for the compound file being created.</param>
+            /// <param name="grfMode">Specifies the access mode to use when opening the new storage object.</param>
+            /// <param name="reserved">Reserved for future use; must be zero.</param>
+            /// <returns>A pointer to the location of the IStorage pointer to the new storage object.</returns>
+            [DllImport("ole32.dll", PreserveSig = false)]
+            [return: MarshalAs(UnmanagedType.Interface)]
+            internal static extern IStorage StgCreateDocfile([MarshalAs(UnmanagedType.LPWStr)] string pwcsName, uint grfMode, uint reserved);
+
+            /// <summary>
+            /// Opens an existing root storage object in the file system.
+            /// </summary>
+            /// <param name="pwcsName">The file that contains the storage object to open.</param>
+            /// <param name="pstgPriority">Most often NULL.</param>
+            /// <param name="grfMode">Specifies the access mode to use to open the storage object.</param>
+            /// <param name="snbExclude">If not NULL, pointer to a block of elements in the storage to be excluded as the storage object is opened.</param>
+            /// <param name="reserved">Indicates reserved for future use; must be zero.</param>
+            /// <returns>A pointer to a IStorage* pointer variable that receives the interface pointer to the opened storage.</returns>
+            [DllImport("ole32.dll", PreserveSig = false)]
+            [return: MarshalAs(UnmanagedType.Interface)]
+            internal static extern IStorage StgOpenStorage([MarshalAs(UnmanagedType.LPWStr)] string pwcsName, IntPtr pstgPriority, uint grfMode, IntPtr snbExclude, uint reserved);
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Patch.cs b/src/WixToolset.Core/Patch.cs
new file mode 100644
index 00000000..e3e6c27f
--- /dev/null
+++ b/src/WixToolset.Core/Patch.cs
@@ -0,0 +1,1284 @@
+// 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.Data
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Globalization;
+    using WixToolset.Data.Rows;
+    using WixToolset.Extensibility;
+    using WixToolset.Msi;
+    using WixToolset.Core.Native;
+
+    /// <summary>
+    /// Values for the OptimizeCA MsiPatchMetdata property, which indicates whether custom actions can be skipped when applying the patch.
+    /// </summary>
+    [Flags]
+    internal enum OptimizeCA
+    {
+        /// <summary>
+        /// No custom actions are skipped.
+        /// </summary>
+        None = 0,
+
+        /// <summary>
+        /// Skip property (type 51) and directory (type 35) assignment custom actions.
+        /// </summary>
+        SkipAssignment = 1,
+
+        /// <summary>
+        /// Skip immediate custom actions that are not property or directory assignment custom actions.
+        /// </summary>
+        SkipImmediate = 2,
+
+        /// <summary>
+        /// Skip custom actions that run within the script.
+        /// </summary>
+        SkipDeferred = 4,
+    }
+
+    /// <summary>
+    /// Contains output tables and logic for building an MSP package.
+    /// </summary>
+    public class Patch
+    {
+        private List<IInspectorExtension> inspectorExtensions;
+        private Output patch;
+        private TableDefinitionCollection tableDefinitions;
+
+        public Output PatchOutput
+        {
+            get { return this.patch; }
+        }
+
+        public Patch()
+        {
+            this.inspectorExtensions = new List<IInspectorExtension>();
+            this.tableDefinitions = new TableDefinitionCollection(WindowsInstallerStandard.GetTableDefinitions());
+        }
+
+        /// <summary>
+        /// Adds an extension.
+        /// </summary>
+        /// <param name="extension">The extension to add.</param>
+        public void AddExtension(IInspectorExtension extension)
+        {
+            this.inspectorExtensions.Add(extension);
+        }
+
+        public void Load(string patchPath)
+        {
+            this.patch = Output.Load(patchPath, false);
+        }
+
+        /// <summary>
+        /// Include transforms in a patch.
+        /// </summary>
+        /// <param name="transforms">List of transforms to attach.</param>
+        [SuppressMessage("Microsoft.Globalization", "CA1303:DoNotPassLiteralsAsLocalizedParameters", MessageId = "System.InvalidOperationException.#ctor(System.String)")]
+        public void AttachTransforms(List<PatchTransform> transforms)
+        {
+            InspectorCore inspectorCore = new InspectorCore();
+
+            // Track if at least one transform gets attached.
+            bool attachedTransform = false;
+
+            if (transforms == null || transforms.Count == 0)
+            {
+                throw new WixException(WixErrors.PatchWithoutTransforms());
+            }
+
+            // Get the patch id from the WixPatchId table.
+            string patchId = null;
+            string clientPatchId = null;
+            Table wixPatchIdTable = this.patch.Tables["WixPatchId"];
+            if (null != wixPatchIdTable && 0 < wixPatchIdTable.Rows.Count)
+            {
+                Row patchIdRow = wixPatchIdTable.Rows[0];
+                if (null != patchIdRow)
+                {
+                    patchId = patchIdRow[0].ToString();
+                    clientPatchId = patchIdRow[1].ToString();
+                }
+            }
+
+            if (null == patchId)
+            {
+                throw new WixException(WixErrors.ExpectedPatchIdInWixMsp());
+            }
+            if (null == clientPatchId)
+            {
+                throw new WixException(WixErrors.ExpectedClientPatchIdInWixMsp());
+            }
+
+            // enumerate patch.Media to map diskId to Media row
+            Table patchMediaTable = patch.Tables["Media"];
+
+            if (null == patchMediaTable || patchMediaTable.Rows.Count == 0)
+            {
+                throw new WixException(WixErrors.ExpectedMediaRowsInWixMsp());
+            }
+
+            Hashtable mediaRows = new Hashtable(patchMediaTable.Rows.Count);
+            foreach (MediaRow row in patchMediaTable.Rows)
+            {
+                int media = row.DiskId;
+                mediaRows[media] = row;
+            }
+
+            // enumerate patch.WixPatchBaseline to map baseline to diskId
+            Table patchBaselineTable = patch.Tables["WixPatchBaseline"];
+
+            int numPatchBaselineRows = (null != patchBaselineTable) ? patchBaselineTable.Rows.Count : 0;
+
+            Hashtable baselineMedia = new Hashtable(numPatchBaselineRows);
+            if (patchBaselineTable != null)
+            {
+                foreach (Row row in patchBaselineTable.Rows)
+                {
+                    string baseline = (string)row[0];
+                    int media = (int)row[1];
+                    int validationFlags = (int)row[2];
+                    if (baselineMedia.Contains(baseline))
+                    {
+                        this.OnMessage(WixErrors.SamePatchBaselineId(row.SourceLineNumbers, baseline));
+                    }
+                    baselineMedia[baseline] = new int[] { media, validationFlags };
+                }
+            }
+
+            // populate MSP summary information
+            Table patchSummaryInfo = patch.EnsureTable(this.tableDefinitions["_SummaryInformation"]);
+
+            // Remove properties that will be calculated or are reserved.
+            for (int i = patchSummaryInfo.Rows.Count - 1; i >= 0; i--)
+            {
+                Row row = patchSummaryInfo.Rows[i];
+                switch ((SummaryInformation.Patch)row[0])
+                {
+                    case SummaryInformation.Patch.ProductCodes:
+                    case SummaryInformation.Patch.TransformNames:
+                    case SummaryInformation.Patch.PatchCode:
+                    case SummaryInformation.Patch.InstallerRequirement:
+                    case SummaryInformation.Patch.Reserved11:
+                    case SummaryInformation.Patch.Reserved14:
+                    case SummaryInformation.Patch.Reserved16:
+                        patchSummaryInfo.Rows.RemoveAt(i);
+                        break;
+                }
+            }
+
+            // Index remaining summary properties.
+            SummaryInfoRowCollection summaryInfo = new SummaryInfoRowCollection(patchSummaryInfo);
+
+            // PID_CODEPAGE
+            if (!summaryInfo.Contains((int)SummaryInformation.Patch.CodePage))
+            {
+                // set the code page by default to the same code page for the
+                // string pool in the database.
+                Row codePage = patchSummaryInfo.CreateRow(null);
+                codePage[0] = (int)SummaryInformation.Patch.CodePage;
+                codePage[1] = this.patch.Codepage.ToString(CultureInfo.InvariantCulture);
+            }
+
+            // GUID patch code for the patch. 
+            Row revisionRow = patchSummaryInfo.CreateRow(null);
+            revisionRow[0] = (int)SummaryInformation.Patch.PatchCode;
+            revisionRow[1] = patchId;
+
+            // Indicates the minimum Windows Installer version that is required to install the patch. 
+            Row wordsRow = patchSummaryInfo.CreateRow(null);
+            wordsRow[0] = (int)SummaryInformation.Patch.InstallerRequirement;
+            wordsRow[1] = ((int)SummaryInformation.InstallerRequirement.Version31).ToString(CultureInfo.InvariantCulture);
+
+            if (!summaryInfo.Contains((int)SummaryInformation.Patch.Security))
+            {
+                Row security = patchSummaryInfo.CreateRow(null);
+                security[0] = (int)SummaryInformation.Patch.Security;
+                security[1] = "4"; // Read-only enforced
+            }
+
+            // use authored comments or default to DisplayName (required)
+            string comments = null;
+
+            Table msiPatchMetadataTable = patch.Tables["MsiPatchMetadata"];
+            Hashtable metadataTable = new Hashtable();
+            if (null != msiPatchMetadataTable)
+            {
+                foreach (Row row in msiPatchMetadataTable.Rows)
+                {
+                    metadataTable.Add(row.Fields[1].Data.ToString(), row.Fields[2].Data.ToString());
+                }
+
+                if (!summaryInfo.Contains((int)SummaryInformation.Patch.Title) && metadataTable.Contains("DisplayName"))
+                {
+                    string displayName = (string)metadataTable["DisplayName"];
+
+                    Row title = patchSummaryInfo.CreateRow(null);
+                    title[0] = (int)SummaryInformation.Patch.Title;
+                    title[1] = displayName;
+
+                    // default comments use DisplayName as-is (no loc)
+                    comments = displayName;
+                }
+
+                if (!summaryInfo.Contains((int)SummaryInformation.Patch.CodePage) && metadataTable.Contains("CodePage"))
+                {
+                    Row codePage = patchSummaryInfo.CreateRow(null);
+                    codePage[0] = (int)SummaryInformation.Patch.CodePage;
+                    codePage[1] = metadataTable["CodePage"];
+                }
+
+                if (!summaryInfo.Contains((int)SummaryInformation.Patch.PackageName) && metadataTable.Contains("Description"))
+                {
+                    Row subject = patchSummaryInfo.CreateRow(null);
+                    subject[0] = (int)SummaryInformation.Patch.PackageName;
+                    subject[1] = metadataTable["Description"];
+                }
+
+                if (!summaryInfo.Contains((int)SummaryInformation.Patch.Manufacturer) && metadataTable.Contains("ManufacturerName"))
+                {
+                    Row author = patchSummaryInfo.CreateRow(null);
+                    author[0] = (int)SummaryInformation.Patch.Manufacturer;
+                    author[1] = metadataTable["ManufacturerName"];
+                }
+            }
+
+            // special metadata marshalled through the build
+            Table wixPatchMetadataTable = patch.Tables["WixPatchMetadata"];
+            Hashtable wixMetadataTable = new Hashtable();
+            if (null != wixPatchMetadataTable)
+            {
+                foreach (Row row in wixPatchMetadataTable.Rows)
+                {
+                    wixMetadataTable.Add(row.Fields[0].Data.ToString(), row.Fields[1].Data.ToString());
+                }
+
+                if (wixMetadataTable.Contains("Comments"))
+                {
+                    comments = (string)wixMetadataTable["Comments"];
+                }
+            }
+
+            // write the package comments to summary info
+            if (!summaryInfo.Contains((int)SummaryInformation.Patch.Comments) && null != comments)
+            {
+                Row commentsRow = patchSummaryInfo.CreateRow(null);
+                commentsRow[0] = (int)SummaryInformation.Patch.Comments;
+                commentsRow[1] = comments;
+            }
+
+            // enumerate transforms
+            Dictionary<string, object> productCodes = new Dictionary<string, object>();
+            ArrayList transformNames = new ArrayList();
+            ArrayList validTransform = new ArrayList();
+            int transformCount = 0;
+            foreach (PatchTransform mainTransform in transforms)
+            {
+                string baseline = null;
+                int media = -1;
+                int validationFlags = 0;
+
+                if (baselineMedia.Contains(mainTransform.Baseline))
+                {
+                    int[] baselineData = (int[])baselineMedia[mainTransform.Baseline];
+                    int newMedia = baselineData[0];
+                    if (media != -1 && media != newMedia)
+                    {
+                        throw new InvalidOperationException(String.Format(CultureInfo.CurrentUICulture, WixStrings.EXP_TransformAuthoredIntoMultipleMedia, media, newMedia));
+                    }
+                    baseline = mainTransform.Baseline;
+                    media = newMedia;
+                    validationFlags = baselineData[1];
+                }
+
+                if (media == -1)
+                {
+                    // transform's baseline not attached to any Media
+                    continue;
+                }
+
+                Table patchRefTable = patch.Tables["WixPatchRef"];
+                if (patchRefTable != null && patchRefTable.Rows.Count > 0)
+                {
+                    if (!Patch.ReduceTransform(mainTransform.Transform, patchRefTable))
+                    {
+                        // transform has none of the content authored into this patch
+                        continue;
+                    }
+                }
+
+                // Validate the transform doesn't break any patch specific rules.
+                mainTransform.Validate();
+
+                // ensure consistent File.Sequence within each Media
+                MediaRow mediaRow = (MediaRow)mediaRows[media];
+
+                // Ensure that files are sequenced after the last file in any transform.
+                Table transformMediaTable = mainTransform.Transform.Tables["Media"];
+                if (null != transformMediaTable && 0 < transformMediaTable.Rows.Count)
+                {
+                    foreach (MediaRow transformMediaRow in transformMediaTable.Rows)
+                    {
+                        if (mediaRow.LastSequence < transformMediaRow.LastSequence)
+                        {
+                            // The Binder will pre-increment the sequence.
+                            mediaRow.LastSequence = transformMediaRow.LastSequence;
+                        }
+                    }
+                }
+
+                // Use the Media/@DiskId if greater for backward compatibility.
+                if (mediaRow.LastSequence < mediaRow.DiskId)
+                {
+                    mediaRow.LastSequence = mediaRow.DiskId;
+                }
+
+                // ignore media table from transform.
+                mainTransform.Transform.Tables.Remove("Media");
+                mainTransform.Transform.Tables.Remove("WixMedia");
+                mainTransform.Transform.Tables.Remove("MsiDigitalSignature");
+
+                string productCode;
+                Output pairedTransform = this.BuildPairedTransform(patchId, clientPatchId, mainTransform.Transform, mediaRow, validationFlags, out productCode);
+                productCodes[productCode] = null;
+                DictionaryEntry entry = new DictionaryEntry();
+                entry.Key = productCode;
+                entry.Value = mainTransform.Transform;
+                validTransform.Add(entry);
+
+                // attach these transforms to the patch object
+                // TODO: is this an acceptable way to auto-generate transform stream names?
+                string transformName = baseline + "." + (++transformCount).ToString(CultureInfo.InvariantCulture);
+                patch.SubStorages.Add(new SubStorage(transformName, mainTransform.Transform));
+                patch.SubStorages.Add(new SubStorage("#" + transformName, pairedTransform));
+                transformNames.Add(":" + transformName);
+                transformNames.Add(":#" + transformName);
+                attachedTransform = true;
+            }
+
+            if (!attachedTransform)
+            {
+                throw new WixException(WixErrors.PatchWithoutValidTransforms());
+            }
+
+            // Validate that a patch authored as removable is actually removable
+            if (metadataTable.Contains("AllowRemoval"))
+            {
+                if ("1" == metadataTable["AllowRemoval"].ToString())
+                {
+                    ArrayList tables = Patch.GetPatchUninstallBreakingTables();
+                    bool result = true;
+                    foreach (DictionaryEntry entry in validTransform)
+                    {
+                        result &= this.CheckUninstallableTransform(entry.Key.ToString(), (Output)entry.Value, tables);
+                    }
+
+                    if (!result)
+                    {
+                        throw new WixException(WixErrors.PatchNotRemovable());
+                    }
+                }
+            }
+
+            // Finish filling tables with transform-dependent data.
+            // Semicolon delimited list of the product codes that can accept the patch.
+            Table wixPatchTargetTable = patch.Tables["WixPatchTarget"];
+            if (null != wixPatchTargetTable)
+            {
+                Dictionary<string, object> targets = new Dictionary<string, object>();
+                bool replace = true;
+                foreach (Row wixPatchTargetRow in wixPatchTargetTable.Rows)
+                {
+                    string target = wixPatchTargetRow[0].ToString();
+                    if (0 == String.CompareOrdinal("*", target))
+                    {
+                        replace = false;
+                    }
+                    else
+                    {
+                        targets[target] = null;
+                    }
+                }
+
+                // Replace the target ProductCodes with the authored list.
+                if (replace)
+                {
+                    productCodes = targets;
+                }
+                else
+                {
+                    // Copy the authored target ProductCodes into the list.
+                    foreach (string target in targets.Keys)
+                    {
+                        productCodes[target] = null;
+                    }
+                }
+            }
+
+            string[] uniqueProductCodes = new string[productCodes.Keys.Count];
+            productCodes.Keys.CopyTo(uniqueProductCodes, 0);
+
+            Row templateRow = patchSummaryInfo.CreateRow(null);
+            templateRow[0] = (int)SummaryInformation.Patch.ProductCodes;
+            templateRow[1] = String.Join(";", uniqueProductCodes);
+
+            // Semicolon delimited list of transform substorage names in the order they are applied.
+            Row savedbyRow = patchSummaryInfo.CreateRow(null);
+            savedbyRow[0] = (int)SummaryInformation.Patch.TransformNames;
+            savedbyRow[1] = String.Join(";", (string[])transformNames.ToArray(typeof(string)));
+
+            // inspect the patch and filtered transforms
+            foreach (InspectorExtension inspectorExtension in this.inspectorExtensions)
+            {
+                inspectorExtension.Core = inspectorCore;
+                inspectorExtension.InspectOutput(this.patch);
+
+                // reset
+                inspectorExtension.Core = null;
+            }
+        }
+
+        /// <summary>
+        /// Ensure transform is uninstallable.
+        /// </summary>
+        /// <param name="productCode">Product code in transform.</param>
+        /// <param name="transform">Transform generated by torch.</param>
+        /// <param name="tables">Tables to be checked</param>
+        /// <returns>True if the transform is uninstallable</returns>
+        private bool CheckUninstallableTransform(string productCode, Output transform, ArrayList tables)
+        {
+            bool ret = true;
+            foreach (string table in tables)
+            {
+                Table wixTable = transform.Tables[table];
+                if (null != wixTable)
+                {
+                    foreach (Row row in wixTable.Rows)
+                    {
+                        if (row.Operation == RowOperation.Add)
+                        {
+                            ret = false;
+                            string primaryKey = row.GetPrimaryKey('/');
+                            if (null == primaryKey)
+                            {
+                                primaryKey = string.Empty;
+                            }
+                            this.OnMessage(WixErrors.NewRowAddedInTable(row.SourceLineNumbers, productCode, wixTable.Name, primaryKey));
+                        }
+                    }
+                }
+            }
+
+            return ret;
+        }
+
+        /// <summary>
+        /// Tables affect patch uninstall.
+        /// </summary>
+        /// <returns>list of tables to be checked</returns>
+        private static ArrayList GetPatchUninstallBreakingTables()
+        {
+            ArrayList tables = new ArrayList();
+            tables.Add("AppId");
+            tables.Add("BindImage");
+            tables.Add("Class");
+            tables.Add("Complus");
+            tables.Add("CreateFolder");
+            tables.Add("DuplicateFile");
+            tables.Add("Environment");
+            tables.Add("Extension");
+            tables.Add("Font");
+            tables.Add("IniFile");
+            tables.Add("IsolatedComponent");
+            tables.Add("LockPermissions");
+            tables.Add("MIME");
+            tables.Add("MoveFile");
+            tables.Add("MsiLockPermissionsEx");
+            tables.Add("MsiServiceConfig");
+            tables.Add("MsiServiceConfigFailureActions");
+            tables.Add("ODBCAttribute");
+            tables.Add("ODBCDataSource");
+            tables.Add("ODBCDriver");
+            tables.Add("ODBCSourceAttribute");
+            tables.Add("ODBCTranslator");
+            tables.Add("ProgId");
+            tables.Add("PublishComponent");
+            tables.Add("RemoveIniFile");
+            tables.Add("SelfReg");
+            tables.Add("ServiceControl");
+            tables.Add("ServiceInstall");
+            tables.Add("TypeLib");
+            tables.Add("Verb");
+
+            return tables;
+        }
+
+        /// <summary>
+        /// Reduce the transform according to the patch references.
+        /// </summary>
+        /// <param name="transform">transform generated by torch.</param>
+        /// <param name="patchRefTable">Table contains patch family filter.</param>
+        /// <returns>true if the transform is not empty</returns>
+        public static bool ReduceTransform(Output transform, Table patchRefTable)
+        {
+            // identify sections to keep
+            Hashtable oldSections = new Hashtable(patchRefTable.Rows.Count);
+            Hashtable newSections = new Hashtable(patchRefTable.Rows.Count);
+            Hashtable tableKeyRows = new Hashtable();
+            ArrayList sequenceList = new ArrayList();
+            Hashtable componentFeatureAddsIndex = new Hashtable();
+            Hashtable customActionTable = new Hashtable();
+            Hashtable directoryTableAdds = new Hashtable();
+            Hashtable featureTableAdds = new Hashtable();
+            Hashtable keptComponents = new Hashtable();
+            Hashtable keptDirectories = new Hashtable();
+            Hashtable keptFeatures = new Hashtable();
+            Hashtable keptLockPermissions = new Hashtable();
+            Hashtable keptMsiLockPermissionExs = new Hashtable();
+
+            Dictionary<string, List<string>> componentCreateFolderIndex = new Dictionary<string, List<string>>();
+            Dictionary<string, List<Row>> directoryLockPermissionsIndex = new Dictionary<string, List<Row>>();
+            Dictionary<string, List<Row>> directoryMsiLockPermissionsExIndex = new Dictionary<string, List<Row>>();
+
+            foreach (Row patchRefRow in patchRefTable.Rows)
+            {
+                string tableName = (string)patchRefRow[0];
+                string key = (string)patchRefRow[1];
+
+                // Short circuit filtering if all changes should be included.
+                if ("*" == tableName && "*" == key)
+                {
+                    Patch.RemoveProductCodeFromTransform(transform);
+                    return true;
+                }
+
+                Table table = transform.Tables[tableName];
+                if (table == null)
+                {
+                    // table not found
+                    continue;
+                }
+
+                // index this table
+                if (!tableKeyRows.Contains(tableName))
+                {
+                    Hashtable newKeyRows = new Hashtable();
+                    foreach (Row newRow in table.Rows)
+                    {
+                        newKeyRows[newRow.GetPrimaryKey('/')] = newRow;
+                    }
+                    tableKeyRows[tableName] = newKeyRows;
+                }
+                Hashtable keyRows = (Hashtable)tableKeyRows[tableName];
+
+                Row row = (Row)keyRows[key];
+                if (row == null)
+                {
+                    // row not found
+                    continue;
+                }
+
+                // Differ.sectionDelimiter
+                string[] sections = row.SectionId.Split('/');
+                oldSections[sections[0]] = row;
+                newSections[sections[1]] = row;
+            }
+
+            // throw away sections not referenced
+            int keptRows = 0;
+            Table directoryTable = null;
+            Table featureTable = null;
+            Table lockPermissionsTable = null;
+            Table msiLockPermissionsTable = null;
+
+            foreach (Table table in transform.Tables)
+            {
+                if ("_SummaryInformation" == table.Name)
+                {
+                    continue;
+                }
+
+                if (table.Name == "AdminExecuteSequence"
+                    || table.Name == "AdminUISequence"
+                    || table.Name == "AdvtExecuteSequence"
+                    || table.Name == "InstallUISequence"
+                    || table.Name == "InstallExecuteSequence")
+                {
+                    sequenceList.Add(table);
+                    continue;
+                }
+
+                for (int i = 0; i < table.Rows.Count; i++)
+                {
+                    Row row = table.Rows[i];
+
+                    if (table.Name == "CreateFolder")
+                    {
+                        string createFolderComponentId = (string)row[1];
+
+                        List<string> directoryList;
+                        if (!componentCreateFolderIndex.TryGetValue(createFolderComponentId, out directoryList))
+                        {
+                            directoryList = new List<string>();
+                            componentCreateFolderIndex.Add(createFolderComponentId, directoryList);
+                        }
+
+                        directoryList.Add((string)row[0]);
+                    }
+
+                    if (table.Name == "CustomAction")
+                    {
+                        customActionTable.Add(row[0], row);
+                    }
+
+                    if (table.Name == "Directory")
+                    {
+                        directoryTable = table;
+                        if (RowOperation.Add == row.Operation)
+                        {
+                            directoryTableAdds.Add(row[0], row);
+                        }
+                    }
+
+                    if (table.Name == "Feature")
+                    {
+                        featureTable = table;
+                        if (RowOperation.Add == row.Operation)
+                        {
+                            featureTableAdds.Add(row[0], row);
+                        }
+                    }
+
+                    if (table.Name == "FeatureComponents")
+                    {
+                        if (RowOperation.Add == row.Operation)
+                        {
+                            string featureId = (string)row[0];
+                            string componentId = (string)row[1];
+
+                            if (componentFeatureAddsIndex.ContainsKey(componentId))
+                            {
+                                ArrayList featureList = (ArrayList)componentFeatureAddsIndex[componentId];
+                                featureList.Add(featureId);
+                            }
+                            else
+                            {
+                                ArrayList featureList = new ArrayList();
+                                componentFeatureAddsIndex.Add(componentId, featureList);
+                                featureList.Add(featureId);
+                            }
+                        }
+                    }
+
+                    if (table.Name == "LockPermissions")
+                    {
+                        lockPermissionsTable = table;
+                        if ("CreateFolder" == (string)row[1])
+                        {
+                            string directoryId = (string)row[0];
+
+                            List<Row> rowList;
+                            if (!directoryLockPermissionsIndex.TryGetValue(directoryId, out rowList))
+                            {
+                                rowList = new List<Row>();
+                                directoryLockPermissionsIndex.Add(directoryId, rowList);
+                            }
+
+                            rowList.Add(row);
+                        }
+                    }
+
+                    if (table.Name == "MsiLockPermissionsEx")
+                    {
+                        msiLockPermissionsTable = table;
+                        if ("CreateFolder" == (string)row[1])
+                        {
+                            string directoryId = (string)row[0];
+
+                            List<Row> rowList;
+                            if (!directoryMsiLockPermissionsExIndex.TryGetValue(directoryId, out rowList))
+                            {
+                                rowList = new List<Row>();
+                                directoryMsiLockPermissionsExIndex.Add(directoryId, rowList);
+                            }
+
+                            rowList.Add(row);
+                        }
+                    }
+
+                    if (null == row.SectionId)
+                    {
+                        table.Rows.RemoveAt(i);
+                        i--;
+                    }
+                    else
+                    {
+                        string[] sections = row.SectionId.Split('/');
+                        // ignore the row without section id.
+                        if (0 == sections[0].Length && 0 == sections[1].Length)
+                        {
+                            table.Rows.RemoveAt(i);
+                            i--;
+                        }
+                        else if (IsInPatchFamily(sections[0], sections[1], oldSections, newSections))
+                        {
+                            if ("Component" == table.Name)
+                            {
+                                keptComponents.Add((string)row[0], row);
+                            }
+
+                            if ("Directory" == table.Name)
+                            {
+                                keptDirectories.Add(row[0], row);
+                            }
+
+                            if ("Feature" == table.Name)
+                            {
+                                keptFeatures.Add(row[0], row);
+                            }
+
+                            keptRows++;
+                        }
+                        else
+                        {
+                            table.Rows.RemoveAt(i);
+                            i--;
+                        }
+                    }
+                }
+            }
+
+            keptRows += ReduceTransformSequenceTable(sequenceList, oldSections, newSections, customActionTable);
+
+            if (null != directoryTable)
+            {
+                foreach (Row componentRow in keptComponents.Values)
+                {
+                    string componentId = (string)componentRow[0];
+
+                    if (RowOperation.Add == componentRow.Operation)
+                    {
+                        // make sure each added component has its required directory and feature heirarchy.
+                        string directoryId = (string)componentRow[2];
+                        while (null != directoryId && directoryTableAdds.ContainsKey(directoryId))
+                        {
+                            Row directoryRow = (Row)directoryTableAdds[directoryId];
+
+                            if (!keptDirectories.ContainsKey(directoryId))
+                            {
+                                directoryTable.Rows.Add(directoryRow);
+                                keptDirectories.Add(directoryRow[0], null);
+                                keptRows++;
+                            }
+
+                            directoryId = (string)directoryRow[1];
+                        }
+
+                        if (componentFeatureAddsIndex.ContainsKey(componentId))
+                        {
+                            foreach (string featureId in (ArrayList)componentFeatureAddsIndex[componentId])
+                            {
+                                string currentFeatureId = featureId;
+                                while (null != currentFeatureId && featureTableAdds.ContainsKey(currentFeatureId))
+                                {
+                                    Row featureRow = (Row)featureTableAdds[currentFeatureId];
+
+                                    if (!keptFeatures.ContainsKey(currentFeatureId))
+                                    {
+                                        featureTable.Rows.Add(featureRow);
+                                        keptFeatures.Add(featureRow[0], null);
+                                        keptRows++;
+                                    }
+
+                                    currentFeatureId = (string)featureRow[1];
+                                }
+                            }
+                        }
+                    }
+
+                    // Hook in changes LockPermissions and MsiLockPermissions for folders for each component that has been kept.
+                    foreach (string keptComponentId in keptComponents.Keys)
+                    {
+                        List<string> directoryList;
+                        if (componentCreateFolderIndex.TryGetValue(keptComponentId, out directoryList))
+                        {
+                            foreach (string directoryId in directoryList)
+                            {
+                                List<Row> lockPermissionsRowList;
+                                if (directoryLockPermissionsIndex.TryGetValue(directoryId, out lockPermissionsRowList))
+                                {
+                                    foreach (Row lockPermissionsRow in lockPermissionsRowList)
+                                    {
+                                        string key = lockPermissionsRow.GetPrimaryKey('/');
+                                        if (!keptLockPermissions.ContainsKey(key))
+                                        {
+                                            lockPermissionsTable.Rows.Add(lockPermissionsRow);
+                                            keptLockPermissions.Add(key, null);
+                                            keptRows++;
+                                        }
+                                    }
+                                }
+
+                                List<Row> msiLockPermissionsExRowList;
+                                if (directoryMsiLockPermissionsExIndex.TryGetValue(directoryId, out msiLockPermissionsExRowList))
+                                {
+                                    foreach (Row msiLockPermissionsExRow in msiLockPermissionsExRowList)
+                                    {
+                                        string key = msiLockPermissionsExRow.GetPrimaryKey('/');
+                                        if (!keptMsiLockPermissionExs.ContainsKey(key))
+                                        {
+                                            msiLockPermissionsTable.Rows.Add(msiLockPermissionsExRow);
+                                            keptMsiLockPermissionExs.Add(key, null);
+                                            keptRows++;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            keptRows += ReduceTransformSequenceTable(sequenceList, oldSections, newSections, customActionTable);
+
+            // Delete tables that are empty.
+            ArrayList tablesToDelete = new ArrayList();
+            foreach (Table table in transform.Tables)
+            {
+                if (0 == table.Rows.Count)
+                {
+                    tablesToDelete.Add(table.Name);
+                }
+            }
+
+            // delete separately to avoid messing up enumeration
+            foreach (string tableName in tablesToDelete)
+            {
+                transform.Tables.Remove(tableName);
+            }
+
+            return keptRows > 0;
+        }
+
+        /// <summary>
+        /// Remove the ProductCode property from the transform.
+        /// </summary>
+        /// <param name="transform">The transform.</param>
+        /// <remarks>
+        /// Changing the ProductCode is not supported in a patch.
+        /// </remarks>
+        private static void RemoveProductCodeFromTransform(Output transform)
+        {
+            Table propertyTable = transform.Tables["Property"];
+            if (null != propertyTable)
+            {
+                for (int i = 0; i < propertyTable.Rows.Count; ++i)
+                {
+                    Row propertyRow = propertyTable.Rows[i];
+                    string property = (string)propertyRow[0];
+
+                    if ("ProductCode" == property)
+                    {
+                        propertyTable.Rows.RemoveAt(i);
+                        break;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Check if the section is in a PatchFamily.
+        /// </summary>
+        /// <param name="oldSection">Section id in target wixout</param>
+        /// <param name="newSection">Section id in upgrade wixout</param>
+        /// <param name="oldSections">Hashtable contains section id should be kept in the baseline wixout.</param>
+        /// <param name="newSections">Hashtable contains section id should be kept in the upgrade wixout.</param>
+        /// <returns>true if section in patch family</returns>
+        private static bool IsInPatchFamily(string oldSection, string newSection, Hashtable oldSections, Hashtable newSections)
+        {
+            bool result = false;
+
+            if ((String.IsNullOrEmpty(oldSection) && newSections.Contains(newSection)) || (String.IsNullOrEmpty(newSection) && oldSections.Contains(oldSection)))
+            {
+                result = true;
+            }
+            else if (!String.IsNullOrEmpty(oldSection) && !String.IsNullOrEmpty(newSection) && (oldSections.Contains(oldSection) || newSections.Contains(newSection)))
+            {
+                result = true;
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Reduce the transform sequence tables.
+        /// </summary>
+        /// <param name="sequenceList">ArrayList of tables to be reduced</param>
+        /// <param name="oldSections">Hashtable contains section id should be kept in the baseline wixout.</param>
+        /// <param name="newSections">Hashtable contains section id should be kept in the target wixout.</param>
+        /// <param name="customAction">Hashtable contains all the rows in the CustomAction table.</param>
+        /// <returns>Number of rows left</returns>
+        private static int ReduceTransformSequenceTable(ArrayList sequenceList, Hashtable oldSections, Hashtable newSections, Hashtable customAction)
+        {
+            int keptRows = 0;
+
+            foreach (Table currentTable in sequenceList)
+            {
+                for (int i = 0; i < currentTable.Rows.Count; i++)
+                {
+                    Row row = currentTable.Rows[i];
+                    string actionName = row.Fields[0].Data.ToString();
+                    string[] sections = row.SectionId.Split('/');
+                    bool isSectionIdEmpty = (sections[0].Length == 0 && sections[1].Length == 0);
+
+                    if (row.Operation == RowOperation.None)
+                    {
+                        // ignore the rows without section id.
+                        if (isSectionIdEmpty)
+                        {
+                            currentTable.Rows.RemoveAt(i);
+                            i--;
+                        }
+                        else if (IsInPatchFamily(sections[0], sections[1], oldSections, newSections))
+                        {
+                            keptRows++;
+                        }
+                        else
+                        {
+                            currentTable.Rows.RemoveAt(i);
+                            i--;
+                        }
+                    }
+                    else if (row.Operation == RowOperation.Modify)
+                    {
+                        bool sequenceChanged = row.Fields[2].Modified;
+                        bool conditionChanged = row.Fields[1].Modified;
+
+                        if (sequenceChanged && !conditionChanged)
+                        {
+                            keptRows++;
+                        }
+                        else if (!sequenceChanged && conditionChanged)
+                        {
+                            if (isSectionIdEmpty)
+                            {
+                                currentTable.Rows.RemoveAt(i);
+                                i--;
+                            }
+                            else if (IsInPatchFamily(sections[0], sections[1], oldSections, newSections))
+                            {
+                                keptRows++;
+                            }
+                            else
+                            {
+                                currentTable.Rows.RemoveAt(i);
+                                i--;
+                            }
+                        }
+                        else if (sequenceChanged && conditionChanged)
+                        {
+                            if (isSectionIdEmpty)
+                            {
+                                row.Fields[1].Modified = false;
+                                keptRows++;
+                            }
+                            else if (IsInPatchFamily(sections[0], sections[1], oldSections, newSections))
+                            {
+                                keptRows++;
+                            }
+                            else
+                            {
+                                row.Fields[1].Modified = false;
+                                keptRows++;
+                            }
+                        }
+                    }
+                    else if (row.Operation == RowOperation.Delete)
+                    {
+                        if (isSectionIdEmpty)
+                        {
+                            // it is a stardard action which is added by wix, we should keep this action.
+                            row.Operation = RowOperation.None;
+                            keptRows++;
+                        }
+                        else if (IsInPatchFamily(sections[0], sections[1], oldSections, newSections))
+                        {
+                            keptRows++;
+                        }
+                        else
+                        {
+                            if (customAction.ContainsKey(actionName))
+                            {
+                                currentTable.Rows.RemoveAt(i);
+                                i--;
+                            }
+                            else
+                            {
+                                // it is a stardard action, we should keep this action.
+                                row.Operation = RowOperation.None;
+                                keptRows++;
+                            }
+                        }
+                    }
+                    else if (row.Operation == RowOperation.Add)
+                    {
+                        if (isSectionIdEmpty)
+                        {
+                            keptRows++;
+                        }
+                        else if (IsInPatchFamily(sections[0], sections[1], oldSections, newSections))
+                        {
+                            keptRows++;
+                        }
+                        else
+                        {
+                            if (customAction.ContainsKey(actionName))
+                            {
+                                currentTable.Rows.RemoveAt(i);
+                                i--;
+                            }
+                            else
+                            {
+                                keptRows++;
+                            }
+                        }
+                    }
+                }
+            }
+
+            return keptRows;
+        }
+
+        /// <summary>
+        /// Create the #transform for the given main transform.
+        /// </summary>
+        /// <param name="patchId">Patch GUID from patch authoring.</param>
+        /// <param name="clientPatchId">Easily referenced identity for this patch.</param>
+        /// <param name="mainTransform">Transform generated by torch.</param>
+        /// <param name="mediaRow">Media authored into patch.</param>
+        /// <param name="validationFlags">Transform validation flags for the summary information stream.</param>
+        /// <param name="productCode">Output string to receive ProductCode.</param>
+        [SuppressMessage("Microsoft.Globalization", "CA1303:DoNotPassLiteralsAsLocalizedParameters", MessageId = "System.InvalidOperationException.#ctor(System.String)")]
+        public Output BuildPairedTransform(string patchId, string clientPatchId, Output mainTransform, MediaRow mediaRow, int validationFlags, out string productCode)
+        {
+            productCode = null;
+            Output pairedTransform = new Output(null);
+            pairedTransform.Type = OutputType.Transform;
+            pairedTransform.Codepage = mainTransform.Codepage;
+
+            // lookup productVersion property to correct summaryInformation
+            string newProductVersion = null;
+            Table mainPropertyTable = mainTransform.Tables["Property"];
+            if (null != mainPropertyTable)
+            {
+                foreach (Row row in mainPropertyTable.Rows)
+                {
+                    if ("ProductVersion" == (string)row[0])
+                    {
+                        newProductVersion = (string)row[1];
+                    }
+                }
+            }
+
+            // TODO: build class for manipulating SummaryInformation table
+            Table mainSummaryTable = mainTransform.Tables["_SummaryInformation"];
+            // add required properties
+            Hashtable mainSummaryRows = new Hashtable();
+            foreach (Row mainSummaryRow in mainSummaryTable.Rows)
+            {
+                mainSummaryRows[mainSummaryRow[0]] = mainSummaryRow;
+            }
+            if (!mainSummaryRows.Contains((int)SummaryInformation.Transform.ValidationFlags))
+            {
+                Row mainSummaryRow = mainSummaryTable.CreateRow(null);
+                mainSummaryRow[0] = (int)SummaryInformation.Transform.ValidationFlags;
+                mainSummaryRow[1] = validationFlags.ToString(CultureInfo.InvariantCulture);
+            }
+
+            // copy summary information from core transform
+            Table pairedSummaryTable = pairedTransform.EnsureTable(this.tableDefinitions["_SummaryInformation"]);
+            foreach (Row mainSummaryRow in mainSummaryTable.Rows)
+            {
+                string value = (string)mainSummaryRow[1];
+                switch ((SummaryInformation.Transform)mainSummaryRow[0])
+                {
+                    case SummaryInformation.Transform.ProductCodes:
+                        string[] propertyData = value.Split(';');
+                        string oldProductVersion = propertyData[0].Substring(38);
+                        string upgradeCode = propertyData[2];
+                        productCode = propertyData[0].Substring(0, 38);
+                        if (newProductVersion == null)
+                        {
+                            newProductVersion = oldProductVersion;
+                        }
+
+                        // force mainTranform to old;new;upgrade and pairedTransform to new;new;upgrade
+                        mainSummaryRow[1] = String.Concat(productCode, oldProductVersion, ';', productCode, newProductVersion, ';', upgradeCode);
+                        value = String.Concat(productCode, newProductVersion, ';', productCode, newProductVersion, ';', upgradeCode);
+                        break;
+                    case SummaryInformation.Transform.ValidationFlags:
+                        // use validation flags authored into the patch XML
+                        mainSummaryRow[1] = value = validationFlags.ToString(CultureInfo.InvariantCulture);
+                        break;
+                }
+                Row pairedSummaryRow = pairedSummaryTable.CreateRow(null);
+                pairedSummaryRow[0] = mainSummaryRow[0];
+                pairedSummaryRow[1] = value;
+            }
+
+            if (productCode == null)
+            {
+                throw new InvalidOperationException(WixStrings.EXP_CouldnotDetermineProductCodeFromTransformSummaryInfo);
+            }
+
+            // copy File table
+            Table mainFileTable = mainTransform.Tables["File"];
+            if (null != mainFileTable && 0 < mainFileTable.Rows.Count)
+            {
+                // We require file source information.
+                Table mainWixFileTable = mainTransform.Tables["WixFile"];
+                if (null == mainWixFileTable)
+                {
+                    throw new WixException(WixErrors.AdminImageRequired(productCode));
+                }
+
+                RowDictionary<FileRow> mainFileRows = new RowDictionary<FileRow>(mainFileTable);
+
+                Table pairedFileTable = pairedTransform.EnsureTable(mainFileTable.Definition);
+                foreach (WixFileRow mainWixFileRow in mainWixFileTable.Rows)
+                {
+                    FileRow mainFileRow = mainFileRows[mainWixFileRow.File];
+
+                    // set File.Sequence to non null to satisfy transform bind
+                    mainFileRow.Sequence = 1;
+
+                    // delete's don't need rows in the paired transform
+                    if (mainFileRow.Operation == RowOperation.Delete)
+                    {
+                        continue;
+                    }
+
+                    FileRow pairedFileRow = (FileRow)pairedFileTable.CreateRow(null);
+                    pairedFileRow.Operation = RowOperation.Modify;
+                    for (int i = 0; i < mainFileRow.Fields.Length; i++)
+                    {
+                        pairedFileRow[i] = mainFileRow[i];
+                    }
+
+                    // override authored media for patch bind
+                    mainWixFileRow.DiskId = mediaRow.DiskId;
+
+                    // suppress any change to File.Sequence to avoid bloat
+                    mainFileRow.Fields[7].Modified = false;
+
+                    // force File row to appear in the transform
+                    switch (mainFileRow.Operation)
+                    {
+                        case RowOperation.Modify:
+                        case RowOperation.Add:
+                            // set msidbFileAttributesPatchAdded
+                            pairedFileRow.Attributes |= MsiInterop.MsidbFileAttributesPatchAdded;
+                            pairedFileRow.Fields[6].Modified = true;
+                            pairedFileRow.Operation = mainFileRow.Operation;
+                            break;
+                        default:
+                            pairedFileRow.Fields[6].Modified = false;
+                            break;
+                    }
+                }
+            }
+
+            // add Media row to pairedTransform
+            Table pairedMediaTable = pairedTransform.EnsureTable(this.tableDefinitions["Media"]);
+            Row pairedMediaRow = pairedMediaTable.CreateRow(null);
+            pairedMediaRow.Operation = RowOperation.Add;
+            for (int i = 0; i < mediaRow.Fields.Length; i++)
+            {
+                pairedMediaRow[i] = mediaRow[i];
+            }
+
+            // add PatchPackage for this Media
+            Table pairedPackageTable = pairedTransform.EnsureTable(this.tableDefinitions["PatchPackage"]);
+            pairedPackageTable.Operation = TableOperation.Add;
+            Row pairedPackageRow = pairedPackageTable.CreateRow(null);
+            pairedPackageRow.Operation = RowOperation.Add;
+            pairedPackageRow[0] = patchId;
+            pairedPackageRow[1] = mediaRow.DiskId;
+
+            // add property to both identify client patches and whether those patches are removable or not
+            int allowRemoval = 0;
+            Table msiPatchMetadataTable = this.patch.Tables["MsiPatchMetadata"];
+            if (null != msiPatchMetadataTable)
+            {
+                foreach (Row msiPatchMetadataRow in msiPatchMetadataTable.Rows)
+                {
+                    // get the value of the standard AllowRemoval property, if present
+                    string company = (string)msiPatchMetadataRow[0];
+                    if ((null == company || 0 == company.Length) && "AllowRemoval" == (string)msiPatchMetadataRow[1])
+                    {
+                        allowRemoval = Int32.Parse((string)msiPatchMetadataRow[2], CultureInfo.InvariantCulture);
+                    }
+                }
+            }
+
+            // add the property to the patch transform's Property table
+            Table pairedPropertyTable = pairedTransform.EnsureTable(this.tableDefinitions["Property"]);
+            pairedPropertyTable.Operation = TableOperation.Add;
+            Row pairedPropertyRow = pairedPropertyTable.CreateRow(null);
+            pairedPropertyRow.Operation = RowOperation.Add;
+            pairedPropertyRow[0] = string.Concat(clientPatchId, ".AllowRemoval");
+            pairedPropertyRow[1] = allowRemoval.ToString(CultureInfo.InvariantCulture);
+
+            // add this patch code GUID to the patch transform to identify
+            // which patches are installed, including in multi-patch
+            // installations.
+            pairedPropertyRow = pairedPropertyTable.CreateRow(null);
+            pairedPropertyRow.Operation = RowOperation.Add;
+            pairedPropertyRow[0] = string.Concat(clientPatchId, ".PatchCode");
+            pairedPropertyRow[1] = patchId;
+
+            // add PATCHNEWPACKAGECODE to apply to admin layouts
+            pairedPropertyRow = pairedPropertyTable.CreateRow(null);
+            pairedPropertyRow.Operation = RowOperation.Add;
+            pairedPropertyRow[0] = "PATCHNEWPACKAGECODE";
+            pairedPropertyRow[1] = patchId;
+
+            // add PATCHNEWSUMMARYCOMMENTS and PATCHNEWSUMMARYSUBJECT to apply to admin layouts
+            Table _summaryInformationTable = this.patch.Tables["_SummaryInformation"];
+            if (null != _summaryInformationTable)
+            {
+                foreach (Row row in _summaryInformationTable.Rows)
+                {
+                    if (3 == (int)row[0]) // PID_SUBJECT
+                    {
+                        pairedPropertyRow = pairedPropertyTable.CreateRow(null);
+                        pairedPropertyRow.Operation = RowOperation.Add;
+                        pairedPropertyRow[0] = "PATCHNEWSUMMARYSUBJECT";
+                        pairedPropertyRow[1] = row[1];
+                    }
+                    else if (6 == (int)row[0]) // PID_COMMENTS
+                    {
+                        pairedPropertyRow = pairedPropertyTable.CreateRow(null);
+                        pairedPropertyRow.Operation = RowOperation.Add;
+                        pairedPropertyRow[0] = "PATCHNEWSUMMARYCOMMENTS";
+                        pairedPropertyRow[1] = row[1];
+                    }
+                }
+            }
+
+            return pairedTransform;
+        }
+
+        /// <summary>
+        /// Sends a message to the message delegate if there is one.
+        /// </summary>
+        /// <param name="mea">Message event arguments.</param>
+        public void OnMessage(MessageEventArgs mea)
+        {
+            Messaging.Instance.OnMessage(mea);
+        }
+    }
+}
diff --git a/src/WixToolset.Core/PatchAPI/PatchInterop.cs b/src/WixToolset.Core/PatchAPI/PatchInterop.cs
new file mode 100644
index 00000000..ce749a33
--- /dev/null
+++ b/src/WixToolset.Core/PatchAPI/PatchInterop.cs
@@ -0,0 +1,1002 @@
+// 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.PatchAPI
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Globalization;
+    using System.Runtime.InteropServices;
+
+    /// <summary>
+    /// Interop class for the mspatchc.dll.
+    /// </summary>
+    internal static class PatchInterop
+    {
+        // From WinError.h in the Platform SDK
+        internal const ushort FACILITY_WIN32 = 7;
+
+        /// <summary>
+        /// Parse a number from text in either hex or decimal.
+        /// </summary>
+        /// <param name="source">Source value. Treated as hex if it starts 0x (or 0X), decimal otherwise.</param>
+        /// <returns>Numeric value that source represents.</returns>
+        static internal UInt32 ParseHexOrDecimal(string source)
+        {
+            string value = source.Trim();
+            if (String.Equals(value.Substring(0,2), "0x", StringComparison.OrdinalIgnoreCase))
+            {
+                return UInt32.Parse(value.Substring(2), NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture.NumberFormat);
+            }
+            else
+            {
+                return UInt32.Parse(value, CultureInfo.InvariantCulture.NumberFormat);
+            }
+        }
+
+        /// <summary>
+        /// Create a binary delta file.
+        /// </summary>
+        /// <param name="deltaFile">Name of the delta file to create.</param>
+        /// <param name="targetFile">Name of updated file.</param>
+        /// <param name="targetSymbolPath">Optional paths to updated file's symbols.</param>
+        /// <param name="targetRetainOffsets">Optional offsets to the delta retain sections in the updated file.</param>
+        /// <param name="basisFiles">Optional array of target files.</param>
+        /// <param name="basisSymbolPaths">Optional array of target files' symbol paths (must match basisFiles array).</param>
+        /// <param name="basisIgnoreLengths">Optional array of target files' delta ignore section lengths (must match basisFiles array)(each entry must match basisIgnoreOffsets entries).</param>
+        /// <param name="basisIgnoreOffsets">Optional array of target files' delta ignore section offsets (must match basisFiles array)(each entry must match basisIgnoreLengths entries).</param>
+        /// <param name="basisRetainLengths">Optional array of target files' delta protect section lengths (must match basisFiles array)(each entry must match basisRetainOffsets and targetRetainOffsets entries).</param>
+        /// <param name="basisRetainOffsets">Optional array of target files' delta protect section offsets (must match basisFiles array)(each entry must match basisRetainLengths and targetRetainOffsets entries).</param>
+        /// <param name="apiPatchingSymbolFlags">ApiPatchingSymbolFlags value.</param>
+        /// <param name="optimizePatchSizeForLargeFiles">OptimizePatchSizeForLargeFiles value.</param>
+        /// <param name="retainRangesIgnored">Flag to indicate retain ranges were ignored due to mismatch.</param>
+        /// <returns>true if delta file was created, false if whole file should be used instead.</returns>
+        static public bool CreateDelta(
+                string deltaFile,
+                string targetFile,
+                string targetSymbolPath,
+                string targetRetainOffsets,
+                string[] basisFiles,
+                string[] basisSymbolPaths,
+                string[] basisIgnoreLengths,
+                string[] basisIgnoreOffsets,
+                string[] basisRetainLengths,
+                string[] basisRetainOffsets,
+                PatchSymbolFlagsType apiPatchingSymbolFlags,
+                bool optimizePatchSizeForLargeFiles,
+                out bool retainRangesIgnored
+                )
+        {
+            retainRangesIgnored = false;
+            if (0 != (apiPatchingSymbolFlags & ~(PatchSymbolFlagsType.PATCH_SYMBOL_NO_IMAGEHLP | PatchSymbolFlagsType.PATCH_SYMBOL_NO_FAILURES | PatchSymbolFlagsType.PATCH_SYMBOL_UNDECORATED_TOO)))
+            {
+                throw new ArgumentOutOfRangeException("apiPatchingSymbolFlags");
+            }
+
+            if (null == deltaFile || 0 == deltaFile.Length)
+            {
+                throw new ArgumentNullException("deltaFile");
+            }
+
+            if (null == targetFile || 0 == targetFile.Length)
+            {
+                throw new ArgumentNullException("targetFile");
+            }
+
+            if (null == basisFiles || 0 == basisFiles.Length)
+            {
+                return false;
+            }
+            uint countOldFiles = (uint) basisFiles.Length;
+
+            if (null != basisSymbolPaths)
+            {
+                if (0 != basisSymbolPaths.Length)
+                {
+                    if ((uint) basisSymbolPaths.Length != countOldFiles)
+                    {
+                        throw new ArgumentOutOfRangeException("basisSymbolPaths");
+                    }
+                }
+            }
+            // a null basisSymbolPaths is allowed.
+
+            if (null != basisIgnoreLengths)
+            {
+                if (0 != basisIgnoreLengths.Length)
+                {
+                    if ((uint) basisIgnoreLengths.Length != countOldFiles)
+                    {
+                        throw new ArgumentOutOfRangeException("basisIgnoreLengths");
+                    }
+                }
+            }
+            else
+            {
+                basisIgnoreLengths = new string[countOldFiles];
+            }
+
+            if (null != basisIgnoreOffsets)
+            {
+                if (0 != basisIgnoreOffsets.Length)
+                {
+                    if ((uint) basisIgnoreOffsets.Length != countOldFiles)
+                    {
+                        throw new ArgumentOutOfRangeException("basisIgnoreOffsets");
+                    }
+                }
+            }
+            else
+            {
+                basisIgnoreOffsets = new string[countOldFiles];
+            }
+
+            if (null != basisRetainLengths)
+            {
+                if (0 != basisRetainLengths.Length)
+                {
+                    if ((uint) basisRetainLengths.Length != countOldFiles)
+                    {
+                        throw new ArgumentOutOfRangeException("basisRetainLengths");
+                    }
+                }
+            }
+            else
+            {
+                basisRetainLengths = new string[countOldFiles];
+            }
+
+            if (null != basisRetainOffsets)
+            {
+                if (0 != basisRetainOffsets.Length)
+                {
+                    if ((uint) basisRetainOffsets.Length != countOldFiles)
+                    {
+                        throw new ArgumentOutOfRangeException("basisRetainOffsets");
+                    }
+                }
+            }
+            else
+            {
+                basisRetainOffsets = new string[countOldFiles];
+            }
+
+            PatchOptionData pod = new PatchOptionData();
+            pod.symbolOptionFlags = apiPatchingSymbolFlags;
+            pod.newFileSymbolPath = targetSymbolPath;
+            pod.oldFileSymbolPathArray = basisSymbolPaths;
+            pod.extendedOptionFlags = 0;
+            PatchOldFileInfoW[] oldFileInfoArray = new PatchOldFileInfoW[countOldFiles];
+            string[] newRetainOffsetArray = ((null == targetRetainOffsets) ? new string[0] : targetRetainOffsets.Split(','));
+            for (uint i = 0; i < countOldFiles; ++i)
+            {
+                PatchOldFileInfoW ofi = new PatchOldFileInfoW();
+                ofi.oldFileName = basisFiles[i];
+                string[] ignoreLengthArray = ((null == basisIgnoreLengths[i]) ? new string[0] : basisIgnoreLengths[i].Split(','));
+                string[] ignoreOffsetArray = ((null == basisIgnoreOffsets[i]) ? new string[0] : basisIgnoreOffsets[i].Split(','));
+                string[] retainLengthArray = ((null == basisRetainLengths[i]) ? new string[0] : basisRetainLengths[i].Split(','));
+                string[] retainOffsetArray = ((null == basisRetainOffsets[i]) ? new string[0] : basisRetainOffsets[i].Split(','));
+                // Validate inputs
+                if (ignoreLengthArray.Length != ignoreOffsetArray.Length)
+                {
+                    throw new ArgumentOutOfRangeException("basisIgnoreLengths");
+                }
+
+                if (retainLengthArray.Length != retainOffsetArray.Length)
+                {
+                    throw new ArgumentOutOfRangeException("basisRetainLengths");
+                }
+
+                if (newRetainOffsetArray.Length != retainOffsetArray.Length)
+                {
+                    // remove all retain range information
+                    retainRangesIgnored = true;
+                    for (uint j = 0; j < countOldFiles; ++j)
+                    {
+                        basisRetainLengths[j] = null;
+                        basisRetainOffsets[j] = null;
+                    }
+                    retainLengthArray = new string[0];
+                    retainOffsetArray = new string[0];
+                    newRetainOffsetArray = new string[0];
+                    for (uint j = 0; j < oldFileInfoArray.Length; ++j)
+                    {
+                        oldFileInfoArray[j].retainRange = null;
+                    }
+                }
+
+                // Populate IgnoreRange structure
+                PatchIgnoreRange[] ignoreArray = null;
+                if (0 != ignoreLengthArray.Length)
+                {
+                    ignoreArray = new PatchIgnoreRange[ignoreLengthArray.Length];
+                    for (int j = 0; j < ignoreLengthArray.Length; ++j)
+                    {
+                        PatchIgnoreRange ignoreRange = new PatchIgnoreRange();
+                        ignoreRange.offsetInOldFile = ParseHexOrDecimal(ignoreOffsetArray[j]);
+                        ignoreRange.lengthInBytes = ParseHexOrDecimal(ignoreLengthArray[j]);
+                        ignoreArray[j] = ignoreRange;
+                    }
+                    ofi.ignoreRange = ignoreArray;
+                }
+
+                PatchRetainRange[] retainArray = null;
+                if (0 != newRetainOffsetArray.Length)
+                {
+                    retainArray = new PatchRetainRange[retainLengthArray.Length];
+                    for (int j = 0; j < newRetainOffsetArray.Length; ++j)
+                    {
+                        PatchRetainRange retainRange = new PatchRetainRange();
+                        retainRange.offsetInOldFile = ParseHexOrDecimal(retainOffsetArray[j]);
+                        retainRange.lengthInBytes = ParseHexOrDecimal(retainLengthArray[j]);
+                        retainRange.offsetInNewFile = ParseHexOrDecimal(newRetainOffsetArray[j]);
+                        retainArray[j] = retainRange;
+                    }
+                    ofi.retainRange = retainArray;
+                }
+                oldFileInfoArray[i] = ofi;
+            }
+
+            if (CreatePatchFileExW(
+                    countOldFiles,
+                    oldFileInfoArray,
+                    targetFile,
+                    deltaFile,
+                    PatchOptionFlags(optimizePatchSizeForLargeFiles),
+                    pod,
+                    null,
+                    IntPtr.Zero))
+            {
+                return true;
+            }
+
+            // determine if this is an error or a need to use whole file.
+            int err = Marshal.GetLastWin32Error();
+            switch(err)
+            {
+            case unchecked((int) ERROR_PATCH_BIGGER_THAN_COMPRESSED):
+                break;
+
+            // too late to exclude this file -- should have been caught before
+            case unchecked((int) ERROR_PATCH_SAME_FILE):
+            default:
+                throw new System.ComponentModel.Win32Exception(err);
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Extract the delta header.
+        /// </summary>
+        /// <param name="delta">Name of delta file.</param>
+        /// <param name="deltaHeader">Name of file to create with the delta's header.</param>
+        static public void ExtractDeltaHeader(string delta, string deltaHeader)
+        {
+            if (!ExtractPatchHeaderToFileW(delta, deltaHeader))
+            {
+                throw new System.ComponentModel.Win32Exception(Marshal.GetLastWin32Error());
+            }
+        }
+
+        /// <summary>
+        /// Returns the PatchOptionFlags to use.
+        /// </summary>
+        /// <param name="optimizeForLargeFiles">True if optimizing for large files.</param>
+        /// <returns>PATCH_OPTION_FLAG values</returns>
+        static private UInt32 PatchOptionFlags(bool optimizeForLargeFiles)
+        {
+            UInt32 flags = PATCH_OPTION_FAIL_IF_SAME_FILE | PATCH_OPTION_FAIL_IF_BIGGER | PATCH_OPTION_USE_LZX_BEST;
+            if (optimizeForLargeFiles)
+            {
+                flags |= PATCH_OPTION_USE_LZX_LARGE;
+            }
+            return flags;
+        }
+
+        //---------------------------------------------------------------------
+        // From PatchApi.h
+        //---------------------------------------------------------------------
+
+        //
+        // The following contants can be combined and used as the OptionFlags
+        // parameter in the patch creation apis.
+
+        internal const uint PATCH_OPTION_USE_BEST          = 0x00000000; // auto choose best (slower)
+
+        internal const uint PATCH_OPTION_USE_LZX_BEST      = 0x00000003; // auto choose best of LXZ A/B (but not large)
+        internal const uint PATCH_OPTION_USE_LZX_A         = 0x00000001; // normal
+        internal const uint PATCH_OPTION_USE_LXZ_B         = 0x00000002; // better on some x86 binaries
+        internal const uint PATCH_OPTION_USE_LZX_LARGE     = 0x00000004; // better support for large files (requires 5.1 or higher applyer)
+
+        internal const uint PATCH_OPTION_NO_BINDFIX        = 0x00010000; // PE bound imports
+        internal const uint PATCH_OPTION_NO_LOCKFIX        = 0x00020000; // PE smashed locks
+        internal const uint PATCH_OPTION_NO_REBASE         = 0x00040000; // PE rebased image
+        internal const uint PATCH_OPTION_FAIL_IF_SAME_FILE = 0x00080000; // don't create if same
+        internal const uint PATCH_OPTION_FAIL_IF_BIGGER    = 0x00100000; // fail if patch is larger than simply compressing new file (slower)
+        internal const uint PATCH_OPTION_NO_CHECKSUM       = 0x00200000; // PE checksum zero
+        internal const uint PATCH_OPTION_NO_RESTIMEFIX     = 0x00400000; // PE resource timestamps
+        internal const uint PATCH_OPTION_NO_TIMESTAMP      = 0x00800000; // don't store new file timestamp in patch
+        internal const uint PATCH_OPTION_SIGNATURE_MD5     = 0x01000000; // use MD5 instead of CRC (reserved for future support)
+        internal const uint PATCH_OPTION_INTERLEAVE_FILES  = 0x40000000; // better support for large files (requires 5.2 or higher applyer)
+        internal const uint PATCH_OPTION_RESERVED1         = 0x80000000; // (used internally)
+
+        internal const uint PATCH_OPTION_VALID_FLAGS       = 0xC0FF0007;
+
+        //
+        // The following flags are used with PATCH_OPTION_DATA SymbolOptionFlags:
+        //
+
+        [Flags]
+        public enum PatchSymbolFlagsType :uint
+        {
+            PATCH_SYMBOL_NO_IMAGEHLP       = 0x00000001, // don't use imagehlp.dll
+            PATCH_SYMBOL_NO_FAILURES       = 0x00000002, // don't fail patch due to imagehlp failures
+            PATCH_SYMBOL_UNDECORATED_TOO   = 0x00000004, // after matching decorated symbols, try to match remaining by undecorated names
+            PATCH_SYMBOL_RESERVED1         = 0x80000000, // (used internally)
+            MaxValue = PATCH_SYMBOL_NO_IMAGEHLP | PATCH_SYMBOL_NO_FAILURES | PATCH_SYMBOL_UNDECORATED_TOO
+        }
+
+        //
+        // The following flags are used with PATCH_OPTION_DATA ExtendedOptionFlags:
+        //
+
+        internal const uint PATCH_TRANSFORM_PE_RESOURCE_2  = 0x00000100; // better handling of PE resources (requires 5.2 or higher applyer)
+        internal const uint PATCH_TRANSFORM_PE_IRELOC_2    = 0x00000200; // better handling of PE stripped relocs (requires 5.2 or higher applyer)
+
+        //
+        // In addition to the standard Win32 error codes, the following error codes may
+        // be returned via GetLastError() when one of the patch APIs fails.
+
+        internal const uint ERROR_PATCH_ENCODE_FAILURE         = 0xC00E3101; // create
+        internal const uint ERROR_PATCH_INVALID_OPTIONS        = 0xC00E3102; // create
+        internal const uint ERROR_PATCH_SAME_FILE              = 0xC00E3103; // create
+        internal const uint ERROR_PATCH_RETAIN_RANGES_DIFFER   = 0xC00E3104; // create
+        internal const uint ERROR_PATCH_BIGGER_THAN_COMPRESSED = 0xC00E3105; // create
+        internal const uint ERROR_PATCH_IMAGEHLP_FALURE        = 0xC00E3106; // create
+
+        /// <summary>
+        /// Delegate type that the PatchAPI calls for progress notification.
+        /// </summary>
+        /// <param name="context">.</param>
+        /// <param name="currentPosition">.</param>
+        /// <param name="maxPosition">.</param>
+        /// <returns>True for success</returns>
+        public delegate bool PatchProgressCallback(
+                IntPtr context,
+                uint currentPosition,
+                uint maxPosition
+                );
+
+        /// <summary>
+        /// Delegate type that the PatchAPI calls for patch symbol load information.
+        /// </summary>
+        /// <param name="whichFile">.</param>
+        /// <param name="symbolFileName">.</param>
+        /// <param name="symType">.</param>
+        /// <param name="symbolFileCheckSum">.</param>
+        /// <param name="symbolFileTimeDate">.</param>
+        /// <param name="imageFileCheckSum">.</param>
+        /// <param name="imageFileTimeDate">.</param>
+        /// <param name="context">.</param>
+        /// <returns>???</returns>
+        public delegate bool PatchSymloadCallback(
+                                                 uint whichFile, // 0 for new file, 1 for first old file, etc
+                [MarshalAs(UnmanagedType.LPStr)] string symbolFileName,
+                                                 uint symType,   // see SYM_TYPE in imagehlp.h
+                                                 uint symbolFileCheckSum,
+                                                 uint symbolFileTimeDate,
+                                                 uint imageFileCheckSum,
+                                                 uint imageFileTimeDate,
+                                                 IntPtr context
+                                                 );
+
+        /// <summary>
+        /// Wraps PATCH_IGNORE_RANGE
+        /// </summary>
+        [StructLayout(LayoutKind.Sequential)]
+        internal class PatchIgnoreRange
+        {
+            public uint offsetInOldFile;
+            public uint lengthInBytes;
+        }
+
+        /// <summary>
+        /// Wraps PATCH_RETAIN_RANGE
+        /// </summary>
+        [StructLayout(LayoutKind.Sequential)]
+        internal class PatchRetainRange
+        {
+            public uint offsetInOldFile;
+            public uint lengthInBytes;
+            public uint offsetInNewFile;
+        }
+
+        /// <summary>
+        /// Wraps PATCH_OLD_FILE_INFO (except for the OldFile~ portion)
+        /// </summary>
+        internal class PatchOldFileInfo
+        {
+            public PatchIgnoreRange[] ignoreRange;
+            public PatchRetainRange[] retainRange;
+        }
+
+        /// <summary>
+        /// Wraps PATCH_OLD_FILE_INFO_W
+        /// </summary>
+        internal class PatchOldFileInfoW : PatchOldFileInfo
+        {
+            public string oldFileName;
+        }
+
+        /// <summary>
+        /// Wraps each PATCH_INTERLEAVE_MAP Range
+        /// </summary>
+        [SuppressMessage("Microsoft.Performance", "CA1812:AvoidUninstantiatedInternalClasses"), StructLayout(LayoutKind.Sequential)]
+        internal class PatchInterleaveMapRange
+        {
+            public uint oldOffset;
+            public uint oldLength;
+            public uint newLength;
+        }
+
+        /// <summary>
+        /// Wraps PATCH_INTERLEAVE_MAP
+        /// </summary>
+        internal class PatchInterleaveMap
+        {
+            public PatchInterleaveMapRange[] ranges = null;
+        }
+
+
+        /// <summary>
+        /// Wraps PATCH_OPTION_DATA
+        /// </summary>
+        [BestFitMapping(false, ThrowOnUnmappableChar = true)]
+        internal class PatchOptionData
+        {
+            public PatchSymbolFlagsType symbolOptionFlags;          // PATCH_SYMBOL_xxx flags
+            [MarshalAs(UnmanagedType.LPStr)] public string               newFileSymbolPath;          // always ANSI, never Unicode
+            [MarshalAs(UnmanagedType.LPStr)] public string[]             oldFileSymbolPathArray;     // array[ OldFileCount ]
+            public uint                 extendedOptionFlags;
+            public PatchSymloadCallback symLoadCallback = null;
+            public IntPtr symLoadContext = IntPtr.Zero;
+            public PatchInterleaveMap[] interleaveMapArray = null;  // array[ OldFileCount ] (requires 5.2 or higher applyer)
+            public uint maxLzxWindowSize = 0;       // limit memory requirements (requires 5.2 or higher applyer)
+        }
+
+        //
+        // Note that PATCH_OPTION_DATA contains LPCSTR paths, and no LPCWSTR (Unicode)
+        // path argument is available, even when used with one of the Unicode APIs
+        // such as CreatePatchFileW. This is because the unlerlying system services
+        // for symbol file handling (IMAGEHLP.DLL) only support ANSI file/path names.
+        //
+
+        //
+        // A note about PATCH_RETAIN_RANGE specifiers with multiple old files:
+        //
+        // Each old version file must have the same RetainRangeCount, and the same
+        // retain range LengthInBytes and OffsetInNewFile values in the same order.
+        // Only the OffsetInOldFile values can differ between old foles for retain
+        // ranges.
+        //
+
+        //
+        // The following prototypes are (some of the) interfaces for creating patches from files.
+        //
+
+        /// <summary>
+        /// Creates a new delta.
+        /// </summary>
+        /// <param name="oldFileCount">Size of oldFileInfoArray.</param>
+        /// <param name="oldFileInfoArray">Target file information.</param>
+        /// <param name="newFileName">Name of updated file.</param>
+        /// <param name="patchFileName">Name of delta to create.</param>
+        /// <param name="optionFlags">PATCH_OPTION_xxx.</param>
+        /// <param name="optionData">Optional PATCH_OPTION_DATA structure.</param>
+        /// <param name="progressCallback">Delegate for progress callbacks.</param>
+        /// <param name="context">Context for progress callback delegate.</param>
+        /// <returns>true if successfull, sets Marshal.GetLastWin32Error() if not.</returns>
+        [DllImport("mspatchc.dll", SetLastError = true, CharSet = CharSet.Unicode, ExactSpelling = true)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static extern bool CreatePatchFileExW(
+                uint oldFileCount,      // maximum 255
+                [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(PatchAPIMarshaler), MarshalCookie="PATCH_OLD_FILE_INFO_W")]
+                PatchOldFileInfoW[] oldFileInfoArray,
+                string newFileName,     // input file  (required)
+                string patchFileName,   // output file (required)
+                uint optionFlags,
+                [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef=typeof(PatchAPIMarshaler), MarshalCookie="PATCH_OPTION_DATA")]
+                PatchOptionData optionData,
+                [MarshalAs (UnmanagedType.FunctionPtr)]
+                PatchProgressCallback progressCallback,
+                IntPtr context
+                );
+
+        /// <summary>
+        /// Extracts delta header from delta.
+        /// </summary>
+        /// <param name="patchFileName">Name of delta file.</param>
+        /// <param name="patchHeaderFileName">Name of file to create with delta header.</param>
+        /// <returns>true if successfull, sets Marshal.GetLastWin32Error() if not.</returns>
+        [DllImport("mspatchc.dll", SetLastError = true, CharSet = CharSet.Unicode, ExactSpelling = true)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static extern bool ExtractPatchHeaderToFileW(
+                string patchFileName,      // input file
+                string patchHeaderFileName // output file
+                );
+
+        // TODO: Add rest of APIs to enable custom binders to perform more exhaustive checks
+
+        /// <summary>
+        /// Marshals arguments for the CreatePatch~ APIs
+        /// </summary>
+        [SuppressMessage("Microsoft.Performance", "CA1812:AvoidUninstantiatedInternalClasses")]
+        internal class PatchAPIMarshaler : ICustomMarshaler
+        {
+            internal static ICustomMarshaler GetInstance(string cookie)
+            {
+                return new PatchAPIMarshaler(cookie);
+            }
+
+            private enum MarshalType
+            {
+                PATCH_OPTION_DATA,
+                PATCH_OLD_FILE_INFO_W
+            };
+            private PatchAPIMarshaler.MarshalType marshalType;
+
+            private PatchAPIMarshaler(string cookie)
+            {
+                this.marshalType = (PatchAPIMarshaler.MarshalType) Enum.Parse(typeof(PatchAPIMarshaler.MarshalType), cookie);
+            }
+
+            //
+            // Summary:
+            //     Returns the size of the native data to be marshaled.
+            //
+            // Returns:
+            //     The size in bytes of the native data.
+            public int GetNativeDataSize()
+            {
+                return Marshal.SizeOf(typeof(IntPtr));
+            }
+
+            //
+            // Summary:
+            //     Performs necessary cleanup of the managed data when it is no longer needed.
+            //
+            // Parameters:
+            //     ManagedObj:
+            //       The managed object to be destroyed.
+            public void CleanUpManagedData(object ManagedObj)
+            {
+            }
+
+            //
+            // Summary:
+            //     Performs necessary cleanup of the unmanaged data when it is no longer needed.
+            //
+            // Parameters:
+            //     pNativeData:
+            //       A pointer to the unmanaged data to be destroyed.
+            public void CleanUpNativeData(IntPtr pNativeData)
+            {
+                if (IntPtr.Zero == pNativeData)
+                {
+                    return;
+                }
+
+                switch (this.marshalType)
+                {
+                case PatchAPIMarshaler.MarshalType.PATCH_OPTION_DATA:
+                    this.CleanUpPOD(pNativeData);
+                    break;
+                default:
+                    this.CleanUpPOFI_A(pNativeData);
+                    break;
+                }
+            }
+
+            //
+            // Summary:
+            //     Converts the managed data to unmanaged data.
+            //
+            // Parameters:
+            //     ManagedObj:
+            //       The managed object to be converted.
+            //
+            // Returns:
+            //     Returns the COM view of the managed object.
+            public IntPtr MarshalManagedToNative(object ManagedObj)
+            {
+                if (null == ManagedObj)
+                {
+                    return IntPtr.Zero;
+                }
+
+                switch(this.marshalType)
+                {
+                case PatchAPIMarshaler.MarshalType.PATCH_OPTION_DATA:
+                    return this.MarshalPOD(ManagedObj as PatchOptionData);
+                case PatchAPIMarshaler.MarshalType.PATCH_OLD_FILE_INFO_W:
+                    return this.MarshalPOFIW_A(ManagedObj as PatchOldFileInfoW[]);
+                default:
+                    throw new InvalidOperationException();
+                }
+            }
+
+
+            //
+            // Summary:
+            //     Converts the unmanaged data to managed data.
+            //
+            // Parameters:
+            //     pNativeData:
+            //       A pointer to the unmanaged data to be wrapped.
+            //
+            // Returns:
+            //     Returns the managed view of the COM data.
+            public object MarshalNativeToManaged(IntPtr pNativeData)
+            {
+                return null;
+            }
+
+            // Implementation *************************************************
+
+            // PATCH_OPTION_DATA offsets
+            private static readonly int symbolOptionFlagsOffset      =   Marshal.SizeOf(typeof(Int32));
+            private static readonly int newFileSymbolPathOffset      = 2*Marshal.SizeOf(typeof(Int32));
+            private static readonly int oldFileSymbolPathArrayOffset = 2*Marshal.SizeOf(typeof(Int32)) + Marshal.SizeOf(typeof(IntPtr));
+            private static readonly int extendedOptionFlagsOffset    = 2*Marshal.SizeOf(typeof(Int32)) + 2*Marshal.SizeOf(typeof(IntPtr));
+            private static readonly int symLoadCallbackOffset        = 3*Marshal.SizeOf(typeof(Int32)) + 2*Marshal.SizeOf(typeof(IntPtr));
+            private static readonly int symLoadContextOffset         = 3*Marshal.SizeOf(typeof(Int32)) + 3*Marshal.SizeOf(typeof(IntPtr));
+            private static readonly int interleaveMapArrayOffset     = 3*Marshal.SizeOf(typeof(Int32)) + 4*Marshal.SizeOf(typeof(IntPtr));
+            private static readonly int maxLzxWindowSizeOffset       = 3*Marshal.SizeOf(typeof(Int32)) + 5*Marshal.SizeOf(typeof(IntPtr));
+            private static readonly int patchOptionDataSize          = 4*Marshal.SizeOf(typeof(Int32)) + 5*Marshal.SizeOf(typeof(IntPtr));
+
+            // PATCH_OLD_FILE_INFO offsets
+            private static readonly int oldFileOffset          =   Marshal.SizeOf(typeof(Int32));
+            private static readonly int ignoreRangeCountOffset =   Marshal.SizeOf(typeof(Int32)) + Marshal.SizeOf(typeof(IntPtr));
+            private static readonly int ignoreRangeArrayOffset = 2*Marshal.SizeOf(typeof(Int32)) + Marshal.SizeOf(typeof(IntPtr));
+            private static readonly int retainRangeCountOffset = 2*Marshal.SizeOf(typeof(Int32)) + 2*Marshal.SizeOf(typeof(IntPtr));
+            private static readonly int retainRangeArrayOffset = 3*Marshal.SizeOf(typeof(Int32)) + 2*Marshal.SizeOf(typeof(IntPtr));
+            private static readonly int patchOldFileInfoSize   = 3*Marshal.SizeOf(typeof(Int32)) + 3*Marshal.SizeOf(typeof(IntPtr));
+
+            // Methods and data used to preserve data needed for cleanup
+
+            // This dictionary holds the quantity of items internal to each native structure that will need to be freed (the OldFileCount)
+            private static readonly Dictionary<IntPtr, int> OldFileCounts = new Dictionary<IntPtr, int>();
+            private static readonly object OldFileCountsLock = new object();
+
+            private IntPtr CreateMainStruct(int oldFileCount)
+            {
+                int nativeSize;
+                switch(this.marshalType)
+                {
+                case PatchAPIMarshaler.MarshalType.PATCH_OPTION_DATA:
+                    nativeSize = patchOptionDataSize;
+                    break;
+                case PatchAPIMarshaler.MarshalType.PATCH_OLD_FILE_INFO_W:
+                    nativeSize = oldFileCount*patchOldFileInfoSize;
+                    break;
+                default:
+                    throw new InvalidOperationException();
+                }
+
+                IntPtr native = Marshal.AllocCoTaskMem(nativeSize);
+
+                lock (PatchAPIMarshaler.OldFileCountsLock)
+                {
+                    PatchAPIMarshaler.OldFileCounts.Add(native, oldFileCount);
+                }
+
+                return native;
+            }
+
+            private static void ReleaseMainStruct(IntPtr native)
+            {
+                lock (PatchAPIMarshaler.OldFileCountsLock)
+                {
+                    PatchAPIMarshaler.OldFileCounts.Remove(native);
+                }
+                Marshal.FreeCoTaskMem(native);
+            }
+
+            private static int GetOldFileCount(IntPtr native)
+            {
+                lock (PatchAPIMarshaler.OldFileCountsLock)
+                {
+                    return PatchAPIMarshaler.OldFileCounts[native];
+                }
+            }
+
+            // Helper methods
+
+            private static IntPtr OptionalAnsiString(string managed)
+            {
+                return (null == managed) ? IntPtr.Zero : Marshal.StringToCoTaskMemAnsi(managed);
+            }
+
+            private static IntPtr OptionalUnicodeString(string managed)
+            {
+                return (null == managed) ? IntPtr.Zero : Marshal.StringToCoTaskMemUni(managed);
+            }
+
+            // string array must be of the same length as the number of old files
+            private static IntPtr CreateArrayOfStringA(string[] managed)
+            {
+                if (null == managed)
+                {
+                    return IntPtr.Zero;
+                }
+
+                int size = managed.Length * Marshal.SizeOf(typeof(IntPtr));
+                IntPtr native = Marshal.AllocCoTaskMem(size);
+
+                for (int i = 0; i < managed.Length; ++i)
+                {
+                    Marshal.WriteIntPtr(native, i*Marshal.SizeOf(typeof(IntPtr)), OptionalAnsiString(managed[i]));
+                }
+
+                return native;
+            }
+
+            // string array must be of the same length as the number of old files
+            private static IntPtr CreateArrayOfStringW(string[] managed)
+            {
+                if (null == managed)
+                {
+                    return IntPtr.Zero;
+                }
+
+                int size = managed.Length * Marshal.SizeOf(typeof(IntPtr));
+                IntPtr native = Marshal.AllocCoTaskMem(size);
+
+                for (int i = 0; i < managed.Length; ++i)
+                {
+                    Marshal.WriteIntPtr(native, i*Marshal.SizeOf(typeof(IntPtr)), OptionalUnicodeString(managed[i]));
+                }
+
+                return native;
+            }
+
+            private static IntPtr CreateInterleaveMapRange(PatchInterleaveMap managed)
+            {
+                if (null == managed)
+                {
+                    return IntPtr.Zero;
+                }
+
+                if (null == managed.ranges)
+                {
+                    return IntPtr.Zero;
+                }
+
+                if (0 == managed.ranges.Length)
+                {
+                    return IntPtr.Zero;
+                }
+
+                IntPtr native = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(UInt32))
+                                        + managed.ranges.Length*(Marshal.SizeOf(typeof(PatchInterleaveMap))));
+                WriteUInt32(native, (uint) managed.ranges.Length);
+
+                for (int i = 0; i < managed.ranges.Length; ++i)
+                {
+                    Marshal.StructureToPtr(managed.ranges[i], (IntPtr)((Int64)native + i*Marshal.SizeOf(typeof(PatchInterleaveMap))), false);
+                }
+                return native;
+            }
+
+            private static IntPtr CreateInterleaveMap(PatchInterleaveMap[] managed)
+            {
+                if (null == managed)
+                {
+                    return IntPtr.Zero;
+                }
+
+                IntPtr native = Marshal.AllocCoTaskMem(managed.Length * Marshal.SizeOf(typeof(IntPtr)));
+
+                for (int i = 0; i < managed.Length; ++i)
+                {
+                    Marshal.WriteIntPtr(native, i*Marshal.SizeOf(typeof(IntPtr)), CreateInterleaveMapRange(managed[i]));
+                }
+
+                return native;
+            }
+
+            private static void WriteUInt32(IntPtr native, uint data)
+            {
+                Marshal.WriteInt32(native, unchecked((int) data));
+            }
+
+            private static void WriteUInt32(IntPtr native, int offset, uint data)
+            {
+                Marshal.WriteInt32(native, offset, unchecked((int) data));
+            }
+
+            // Marshal operations
+
+            private IntPtr MarshalPOD(PatchOptionData managed)
+            {
+                if (null == managed)
+                {
+                    throw new ArgumentNullException("managed");
+                }
+
+                IntPtr native = this.CreateMainStruct(managed.oldFileSymbolPathArray.Length);
+                Marshal.WriteInt32(native, patchOptionDataSize); // SizeOfThisStruct
+                WriteUInt32(native, symbolOptionFlagsOffset, (uint) managed.symbolOptionFlags);
+                Marshal.WriteIntPtr(native, newFileSymbolPathOffset, PatchAPIMarshaler.OptionalAnsiString(managed.newFileSymbolPath));
+                Marshal.WriteIntPtr(native, oldFileSymbolPathArrayOffset, PatchAPIMarshaler.CreateArrayOfStringA(managed.oldFileSymbolPathArray));
+                WriteUInt32(native, extendedOptionFlagsOffset, managed.extendedOptionFlags);
+
+                // GetFunctionPointerForDelegate() throws an ArgumentNullException if the delegate is null.
+                if (null == managed.symLoadCallback)
+                {
+                    Marshal.WriteIntPtr(native, symLoadCallbackOffset, IntPtr.Zero);
+                }
+                else
+                {
+                    Marshal.WriteIntPtr(native, symLoadCallbackOffset, Marshal.GetFunctionPointerForDelegate(managed.symLoadCallback));
+                }
+
+                Marshal.WriteIntPtr(native, symLoadContextOffset, managed.symLoadContext);
+                Marshal.WriteIntPtr(native, interleaveMapArrayOffset, PatchAPIMarshaler.CreateInterleaveMap(managed.interleaveMapArray));
+                WriteUInt32(native, maxLzxWindowSizeOffset, managed.maxLzxWindowSize);
+                return native;
+            }
+
+            private IntPtr MarshalPOFIW_A(PatchOldFileInfoW[] managed)
+            {
+                if (null == managed)
+                {
+                    throw new ArgumentNullException("managed");
+                }
+
+                if (0 == managed.Length)
+                {
+                    return IntPtr.Zero;
+                }
+
+                IntPtr native = this.CreateMainStruct(managed.Length);
+
+                for (int i = 0; i < managed.Length; ++i)
+                {
+                    PatchAPIMarshaler.MarshalPOFIW(managed[i], (IntPtr)((Int64)native + i * patchOldFileInfoSize));
+                }
+
+                return native;
+            }
+
+            private static void MarshalPOFIW(PatchOldFileInfoW managed, IntPtr native)
+            {
+                PatchAPIMarshaler.MarshalPOFI(managed, native);
+                Marshal.WriteIntPtr(native, oldFileOffset, PatchAPIMarshaler.OptionalUnicodeString(managed.oldFileName)); // OldFileName
+            }
+
+            private static void MarshalPOFI(PatchOldFileInfo managed, IntPtr native)
+            {
+                Marshal.WriteInt32(native, patchOldFileInfoSize); // SizeOfThisStruct
+                WriteUInt32(native, ignoreRangeCountOffset,
+                                    (null == managed.ignoreRange) ? 0 : (uint) managed.ignoreRange.Length); // IgnoreRangeCount // maximum 255
+                Marshal.WriteIntPtr(native, ignoreRangeArrayOffset, MarshalPIRArray(managed.ignoreRange));  // IgnoreRangeArray
+                WriteUInt32(native, retainRangeCountOffset,
+                                    (null == managed.retainRange) ? 0 : (uint) managed.retainRange.Length); // RetainRangeCount // maximum 255
+                Marshal.WriteIntPtr(native, retainRangeArrayOffset, MarshalPRRArray(managed.retainRange));  // RetainRangeArray
+            }
+
+            private static IntPtr MarshalPIRArray(PatchIgnoreRange[] array)
+            {
+                if (null == array)
+                {
+                    return IntPtr.Zero;
+                }
+
+                if (0 == array.Length)
+                {
+                    return IntPtr.Zero;
+                }
+
+                IntPtr native = Marshal.AllocCoTaskMem(array.Length*Marshal.SizeOf(typeof(PatchIgnoreRange)));
+
+                for (int i = 0; i < array.Length; ++i)
+                {
+                    Marshal.StructureToPtr(array[i], (IntPtr)((Int64)native + (i*Marshal.SizeOf(typeof(PatchIgnoreRange)))), false);
+                }
+
+                return native;
+            }
+
+            private static IntPtr MarshalPRRArray(PatchRetainRange[] array)
+            {
+                if (null == array)
+                {
+                    return IntPtr.Zero;
+                }
+
+                if (0 == array.Length)
+                {
+                    return IntPtr.Zero;
+                }
+
+                IntPtr native = Marshal.AllocCoTaskMem(array.Length*Marshal.SizeOf(typeof(PatchRetainRange)));
+
+                for (int i = 0; i < array.Length; ++i)
+                {
+                    Marshal.StructureToPtr(array[i], (IntPtr)((Int64)native + (i*Marshal.SizeOf(typeof(PatchRetainRange)))), false);
+                }
+
+                return native;
+            }
+
+            // CleanUp operations
+
+            private void CleanUpPOD(IntPtr native)
+            {
+                Marshal.FreeCoTaskMem(Marshal.ReadIntPtr(native, newFileSymbolPathOffset));
+
+                if (IntPtr.Zero != Marshal.ReadIntPtr(native, oldFileSymbolPathArrayOffset))
+                {
+                    for (int i = 0; i < GetOldFileCount(native); ++i)
+                    {
+                        Marshal.FreeCoTaskMem(
+                                Marshal.ReadIntPtr(
+                                        Marshal.ReadIntPtr(native, oldFileSymbolPathArrayOffset),
+                                        i*Marshal.SizeOf(typeof(IntPtr))));
+                    }
+
+                    Marshal.FreeCoTaskMem(Marshal.ReadIntPtr(native, oldFileSymbolPathArrayOffset));
+                }
+
+                if (IntPtr.Zero != Marshal.ReadIntPtr(native, interleaveMapArrayOffset))
+                {
+                    for (int i = 0; i < GetOldFileCount(native); ++i)
+                    {
+                        Marshal.FreeCoTaskMem(
+                                Marshal.ReadIntPtr(
+                                        Marshal.ReadIntPtr(native, interleaveMapArrayOffset),
+                                        i*Marshal.SizeOf(typeof(IntPtr))));
+                    }
+
+                    Marshal.FreeCoTaskMem(Marshal.ReadIntPtr(native, interleaveMapArrayOffset));
+                }
+
+                PatchAPIMarshaler.ReleaseMainStruct(native);
+            }
+
+            private void CleanUpPOFI_A(IntPtr native)
+            {
+                for (int i = 0; i < GetOldFileCount(native); ++i)
+                {
+                    PatchAPIMarshaler.CleanUpPOFI((IntPtr)((Int64)native + i*patchOldFileInfoSize));
+                }
+
+                PatchAPIMarshaler.ReleaseMainStruct(native);
+            }
+
+            private static void CleanUpPOFI(IntPtr native)
+            {
+                if (IntPtr.Zero != Marshal.ReadIntPtr(native, oldFileOffset))
+                {
+                    Marshal.FreeCoTaskMem(Marshal.ReadIntPtr(native, oldFileOffset));
+                }
+
+                PatchAPIMarshaler.CleanUpPOFIH(native);
+            }
+
+            private static void CleanUpPOFIH(IntPtr native)
+            {
+                if (IntPtr.Zero != Marshal.ReadIntPtr(native, ignoreRangeArrayOffset))
+                {
+                    Marshal.FreeCoTaskMem(Marshal.ReadIntPtr(native, ignoreRangeArrayOffset));
+                }
+
+                if (IntPtr.Zero != Marshal.ReadIntPtr(native, retainRangeArrayOffset))
+                {
+                    Marshal.FreeCoTaskMem(Marshal.ReadIntPtr(native, retainRangeArrayOffset));
+                }
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/PatchTransform.cs b/src/WixToolset.Core/PatchTransform.cs
new file mode 100644
index 00000000..c87b1a21
--- /dev/null
+++ b/src/WixToolset.Core/PatchTransform.cs
@@ -0,0 +1,274 @@
+// 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
+{
+    using System;
+    using System.Collections;
+    using System.Globalization;
+    using System.Text;
+    using System.Text.RegularExpressions;
+    using WixToolset.Data;
+    using WixToolset.Extensibility;
+
+    public class PatchTransform : IMessageHandler
+    {
+        private string baseline;
+        private Output transform;
+        private string transformPath;
+
+        public string Baseline
+        {
+            get { return this.baseline; }
+        }
+
+        public Output Transform
+        {
+            get
+            {
+                if (null == this.transform)
+                {
+                    this.transform = Output.Load(this.transformPath, false);
+                }
+
+                return this.transform;
+            }
+        }
+
+        public string TransformPath
+        {
+            get { return this.transformPath; }
+        }
+
+        public PatchTransform(string transformPath, string baseline)
+        {
+            this.transformPath = transformPath;
+            this.baseline = baseline;
+        }
+
+        /// <summary>
+        /// Validates that the differences in the transform are valid for patch transforms.
+        /// </summary>
+        public void Validate()
+        {
+            // Changing the ProdocutCode in a patch transform is not recommended.
+            Table propertyTable = this.Transform.Tables["Property"];
+            if (null != propertyTable)
+            {
+                foreach (Row row in propertyTable.Rows)
+                {
+                    // Only interested in modified rows; fast check.
+                    if (RowOperation.Modify == row.Operation)
+                    {
+                        if (0 == String.CompareOrdinal("ProductCode", (string)row[0]))
+                        {
+                            this.OnMessage(WixWarnings.MajorUpgradePatchNotRecommended());
+                        }
+                    }
+                }
+            }
+
+            // If there is nothing in the component table we can return early because the remaining checks are component based.
+            Table componentTable = this.Transform.Tables["Component"];
+            if (null == componentTable)
+            {
+                return;
+            }
+
+            // Index Feature table row operations
+            Table featureTable = this.Transform.Tables["Feature"];
+            Table featureComponentsTable = this.Transform.Tables["FeatureComponents"];
+            Hashtable featureOps = null;
+            if (null != featureTable)
+            {
+                int capacity = featureTable.Rows.Count;
+                featureOps = new Hashtable(capacity);
+
+                foreach (Row row in featureTable.Rows)
+                {
+                    featureOps[(string)row[0]] = row.Operation;
+                }
+            }
+            else
+            {
+                featureOps = new Hashtable();
+            }
+
+            // Index Component table and check for keypath modifications
+            Hashtable deletedComponent = new Hashtable();
+            Hashtable componentKeyPath = new Hashtable();
+            foreach (Row row in componentTable.Rows)
+            {
+                string id = row.Fields[0].Data.ToString();
+                string keypath = (null == row.Fields[5].Data) ? String.Empty : row.Fields[5].Data.ToString();
+
+                componentKeyPath.Add(id, keypath);
+                if (RowOperation.Delete == row.Operation)
+                {
+                    deletedComponent.Add(id, row);
+                }
+                else if (RowOperation.Modify == row.Operation)
+                {
+                    if (row.Fields[1].Modified)
+                    {
+                        // Changing the guid of a component is equal to deleting the old one and adding a new one.
+                        deletedComponent.Add(id, row);
+                    }
+
+                    // If the keypath is modified its an error
+                    if (row.Fields[5].Modified)
+                    {
+                        this.OnMessage(WixErrors.InvalidKeypathChange(row.SourceLineNumbers, id, this.transformPath));
+                    }
+                }
+            }
+
+            // Verify changes in the file table
+            Table fileTable = this.Transform.Tables["File"];
+            if (null != fileTable)
+            {
+                Hashtable componentWithChangedKeyPath = new Hashtable();
+                foreach (Row row in fileTable.Rows)
+                {
+                    if (RowOperation.None != row.Operation)
+                    {
+                        string fileId = row.Fields[0].Data.ToString();
+                        string componentId = row.Fields[1].Data.ToString();
+
+                        // If this file is the keypath of a component
+                        if (String.Equals((string)componentKeyPath[componentId], fileId, StringComparison.Ordinal))
+                        {
+                            if (row.Fields[2].Modified)
+                            {
+                                // You cant change the filename of a file that is the keypath of a component.
+                                this.OnMessage(WixErrors.InvalidKeypathChange(row.SourceLineNumbers, componentId, this.transformPath));
+                            }
+
+                            if (!componentWithChangedKeyPath.ContainsKey(componentId))
+                            {
+                                componentWithChangedKeyPath.Add(componentId, fileId);
+                            }
+                        }
+
+                        if (RowOperation.Delete == row.Operation)
+                        {
+                            // If the file is removed from a component that is not deleted.
+                            if (!deletedComponent.ContainsKey(componentId))
+                            {
+                                bool foundRemoveFileEntry = false;
+                                string filename = Msi.Installer.GetName((string)row[2], false, true);
+
+                                Table removeFileTable = this.Transform.Tables["RemoveFile"];
+                                if (null != removeFileTable)
+                                {
+                                    foreach (Row removeFileRow in removeFileTable.Rows)
+                                    {
+                                        if (RowOperation.Delete == removeFileRow.Operation)
+                                        {
+                                            continue;
+                                        }
+
+                                        if (componentId == (string)removeFileRow[1])
+                                        {
+                                            // Check if there is a RemoveFile entry for this file
+                                            if (null != removeFileRow[2])
+                                            {
+                                                string removeFileName = Msi.Installer.GetName((string)removeFileRow[2], false, true);
+
+                                                // Convert the MSI format for a wildcard string to Regex format.
+                                                removeFileName = removeFileName.Replace('.', '|').Replace('?', '.').Replace("*", ".*").Replace("|", "\\.");
+
+                                                Regex regex = new Regex(removeFileName, RegexOptions.CultureInvariant | RegexOptions.IgnoreCase);
+                                                if (regex.IsMatch(filename))
+                                                {
+                                                    foundRemoveFileEntry = true;
+                                                    break;
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+
+                                if (!foundRemoveFileEntry)
+                                {
+                                    this.OnMessage(WixWarnings.InvalidRemoveFile(row.SourceLineNumbers, fileId, componentId));
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+
+            if (0 < deletedComponent.Count)
+            {
+                // Index FeatureComponents table.
+                Hashtable featureComponents = new Hashtable();
+
+                if (null != featureComponentsTable)
+                {
+                    foreach (Row row in featureComponentsTable.Rows)
+                    {
+                        ArrayList features;
+                        string componentId = row.Fields[1].Data.ToString();
+
+                        if (featureComponents.Contains(componentId))
+                        {
+                            features = (ArrayList)featureComponents[componentId];
+                        }
+                        else
+                        {
+                            features = new ArrayList();
+                            featureComponents.Add(componentId, features);
+                        }
+                        features.Add(row.Fields[0].Data.ToString());
+                    }
+                }
+
+                // Check to make sure if a component was deleted, the feature was too.
+                foreach (DictionaryEntry entry in deletedComponent)
+                {
+                    if (featureComponents.Contains(entry.Key.ToString()))
+                    {
+                        ArrayList features = (ArrayList)featureComponents[entry.Key.ToString()];
+                        foreach (string featureId in features)
+                        {
+                            if (!featureOps.ContainsKey(featureId) || RowOperation.Delete != (RowOperation)featureOps[featureId])
+                            {
+                                // The feature was not deleted.
+                                this.OnMessage(WixErrors.InvalidRemoveComponent(((Row)entry.Value).SourceLineNumbers, entry.Key.ToString(), featureId, this.transformPath));
+                            }
+                        }
+                    }
+                }
+            }
+
+            // Warn if new components are added to existing features
+            if (null != featureComponentsTable)
+            {
+                foreach (Row row in featureComponentsTable.Rows)
+                {
+                    if (RowOperation.Add == row.Operation)
+                    {
+                        // Check if the feature is in the Feature table
+                        string feature_ = (string)row[0];
+                        string component_ = (string)row[1];
+
+                        // Features may not be present if not referenced
+                        if (!featureOps.ContainsKey(feature_) || RowOperation.Add != (RowOperation)featureOps[feature_])
+                        {
+                            this.OnMessage(WixWarnings.NewComponentAddedToExistingFeature(row.SourceLineNumbers, component_, feature_, this.transformPath));
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Sends a message to the message delegate if there is one.
+        /// </summary>
+        /// <param name="mea">Message event arguments.</param>
+        public void OnMessage(MessageEventArgs e)
+        {
+            Messaging.Instance.OnMessage(e);
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Preprocess/IfContext.cs b/src/WixToolset.Core/Preprocess/IfContext.cs
new file mode 100644
index 00000000..64b5bd91
--- /dev/null
+++ b/src/WixToolset.Core/Preprocess/IfContext.cs
@@ -0,0 +1,110 @@
+// 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.Preprocess
+{
+    using System;
+
+    /// <summary>
+    /// Current state of the if context.
+    /// </summary>
+    internal enum IfState
+    {
+        /// <summary>Context currently in unknown state.</summary>
+        Unknown,
+
+        /// <summary>Context currently inside if statement.</summary>
+        If,
+
+        /// <summary>Context currently inside elseif statement..</summary>
+        ElseIf,
+
+        /// <summary>Conext currently inside else statement.</summary>
+        Else,
+    }
+
+    /// <summary>
+    /// Context for an if statement in the preprocessor.
+    /// </summary>
+    internal sealed class IfContext
+    {
+        private bool active;
+        private bool keep;
+        private bool everKept;
+        private IfState state;
+
+        /// <summary>
+        /// Creates a default if context object, which are used for if's within an inactive preprocessor block
+        /// </summary>
+        public IfContext()
+        {
+            this.active = false;
+            this.keep = false;
+            this.everKept = true;
+            this.state = IfState.If;
+        }
+
+        /// <summary>
+        /// Creates an if context object.
+        /// </summary>
+        /// <param name="active">Flag if context is currently active.</param>
+        /// <param name="keep">Flag if context is currently true.</param>
+        /// <param name="state">State of context to start in.</param>
+        public IfContext(bool active, bool keep, IfState state)
+        {
+            this.active = active;
+            this.keep = keep;
+            this.everKept = keep;
+            this.state = state;
+        }
+
+        /// <summary>
+        /// Gets and sets if this if context is currently active.
+        /// </summary>
+        /// <value>true if context is active.</value>
+        public bool Active
+        {
+            get { return this.active; }
+            set { this.active = value; }
+        }
+
+        /// <summary>
+        /// Gets and sets if context is current true.
+        /// </summary>
+        /// <value>true if context is currently true.</value>
+        public bool IsTrue
+        {
+            get
+            {
+                return this.keep;
+            }
+
+            set
+            {
+                this.keep = value;
+                if (this.keep)
+                {
+                    this.everKept = true;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Gets if the context was ever true.
+        /// </summary>
+        /// <value>True if context was ever true.</value>
+        public bool WasEverTrue
+        {
+            get { return this.everKept; }
+        }
+
+        /// <summary>
+        /// Gets the current state of the if context.
+        /// </summary>
+        /// <value>Current state of context.</value>
+        public IfState IfState
+        {
+            get { return this.state; }
+            set { this.state = value; }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Preprocessor.cs b/src/WixToolset.Core/Preprocessor.cs
new file mode 100644
index 00000000..a9fbcbb7
--- /dev/null
+++ b/src/WixToolset.Core/Preprocessor.cs
@@ -0,0 +1,1598 @@
+// 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
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Globalization;
+    using System.IO;
+    using System.Text;
+    using System.Text.RegularExpressions;
+    using System.Xml;
+    using System.Xml.Linq;
+    using WixToolset.Data;
+    using WixToolset.Extensibility;
+    using WixToolset.Preprocess;
+
+    /// <summary>
+    /// Preprocessor object
+    /// </summary>
+    public sealed class Preprocessor
+    {
+        private readonly Regex defineRegex = new Regex(@"^\s*(?<varName>.+?)\s*(=\s*(?<varValue>.+?)\s*)?$", RegexOptions.Compiled | RegexOptions.Singleline | RegexOptions.ExplicitCapture);
+        private readonly Regex pragmaRegex = new Regex(@"^\s*(?<pragmaName>.+?)(?<pragmaValue>[\s\(].+?)?$", RegexOptions.Compiled | RegexOptions.Singleline | RegexOptions.ExplicitCapture);
+
+        private readonly XmlReaderSettings DocumentXmlReaderSettings = new XmlReaderSettings()
+        {
+            ValidationFlags = System.Xml.Schema.XmlSchemaValidationFlags.None,
+            XmlResolver = null,
+        };
+        private readonly XmlReaderSettings FragmentXmlReaderSettings = new XmlReaderSettings()
+        {
+            ConformanceLevel = System.Xml.ConformanceLevel.Fragment,
+            ValidationFlags = System.Xml.Schema.XmlSchemaValidationFlags.None,
+            XmlResolver = null,
+        };
+
+        private List<IPreprocessorExtension> extensions;
+        private Dictionary<string, IPreprocessorExtension> extensionsByPrefix;
+        private List<InspectorExtension> inspectorExtensions;
+
+        private SourceLineNumber currentLineNumber;
+        private Stack<SourceLineNumber> sourceStack;
+
+        private PreprocessorCore core;
+        private TextWriter preprocessOut;
+
+        private Stack<bool> includeNextStack;
+        private Stack<string> currentFileStack;
+
+        private Platform currentPlatform;
+
+        /// <summary>
+        /// Creates a new preprocesor.
+        /// </summary>
+        public Preprocessor()
+        {
+            this.IncludeSearchPaths = new List<string>();
+
+            this.extensions = new List<IPreprocessorExtension>();
+            this.extensionsByPrefix = new Dictionary<string, IPreprocessorExtension>();
+            this.inspectorExtensions = new List<InspectorExtension>();
+
+            this.sourceStack = new Stack<SourceLineNumber>();
+
+            this.includeNextStack = new Stack<bool>();
+            this.currentFileStack = new Stack<string>();
+
+            this.currentPlatform = Platform.X86;
+        }
+
+        /// <summary>
+        /// Event for ifdef/ifndef directives.
+        /// </summary>
+        public event IfDefEventHandler IfDef;
+
+        /// <summary>
+        /// Event for included files.
+        /// </summary>
+        public event IncludedFileEventHandler IncludedFile;
+
+        /// <summary>
+        /// Event for preprocessed stream.
+        /// </summary>
+        public event ProcessedStreamEventHandler ProcessedStream;
+
+        /// <summary>
+        /// Event for resolved variables.
+        /// </summary>
+        public event ResolvedVariableEventHandler ResolvedVariable;
+
+        /// <summary>
+        /// Enumeration for preprocessor operations in if statements.
+        /// </summary>
+        private enum PreprocessorOperation
+        {
+            /// <summary>The and operator.</summary>
+            And,
+
+            /// <summary>The or operator.</summary>
+            Or,
+
+            /// <summary>The not operator.</summary>
+            Not
+        }
+
+        /// <summary>
+        /// Gets or sets the platform which the compiler will use when defaulting 64-bit attributes and elements.
+        /// </summary>
+        /// <value>The platform which the compiler will use when defaulting 64-bit attributes and elements.</value>
+        public Platform CurrentPlatform
+        {
+            get { return this.currentPlatform; }
+            set { this.currentPlatform = value; }
+        }
+
+        /// <summary>
+        /// Ordered list of search paths that the precompiler uses to find included files.
+        /// </summary>
+        /// <value>List of ordered search paths to use during precompiling.</value>
+        public IList<string> IncludeSearchPaths { get; private set; }
+
+        /// <summary>
+        /// Specifies the text stream to display the postprocessed data to.
+        /// </summary>
+        /// <value>TextWriter to write preprocessed xml to.</value>
+        public TextWriter PreprocessOut
+        {
+            get { return this.preprocessOut; }
+            set { this.preprocessOut = value; }
+        }
+
+        /// <summary>
+        /// Get the source line information for the current element.  The precompiler will insert
+        /// special source line number processing instructions before each element that it
+        /// encounters.  This is where those line numbers are read and processed.  This function
+        /// may return an array of source line numbers because the element may have come from
+        /// an included file, in which case the chain of imports is expressed in the array.
+        /// </summary>
+        /// <param name="node">Element to get source line information for.</param>
+        /// <returns>Returns the stack of imports used to author the element being processed.</returns>
+        [SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes")]
+        public static SourceLineNumber GetSourceLineNumbers(XmlNode node)
+        {
+            return null;
+        }
+
+        /// <summary>
+        /// Get the source line information for the current element.  The precompiler will insert
+        /// special source line number information for each element that it encounters.
+        /// </summary>
+        /// <param name="node">Element to get source line information for.</param>
+        /// <returns>
+        /// The source line number used to author the element being processed or
+        /// null if the preprocessor did not process the element or the node is
+        /// not an element.
+        /// </returns>
+        public static SourceLineNumber GetSourceLineNumbers(XObject node)
+        {
+            return SourceLineNumber.GetFromXAnnotation(node);
+        }
+
+        /// <summary>
+        /// Adds an extension.
+        /// </summary>
+        /// <param name="extension">The extension to add.</param>
+        public void AddExtension(IPreprocessorExtension extension)
+        {
+            this.extensions.Add(extension);
+
+            if (null != extension.Prefixes)
+            {
+                foreach (string prefix in extension.Prefixes)
+                {
+                    IPreprocessorExtension collidingExtension;
+                    if (!this.extensionsByPrefix.TryGetValue(prefix, out collidingExtension))
+                    {
+                        this.extensionsByPrefix.Add(prefix, extension);
+                    }
+                    else
+                    {
+                        Messaging.Instance.OnMessage(WixErrors.DuplicateExtensionPreprocessorType(extension.GetType().ToString(), prefix, collidingExtension.GetType().ToString()));
+                    }
+                }
+            }
+
+            //if (null != extension.InspectorExtension)
+            //{
+            //    this.inspectorExtensions.Add(extension.InspectorExtension);
+            //}
+        }
+
+        /// <summary>
+        /// Preprocesses a file.
+        /// </summary>
+        /// <param name="sourceFile">The file to preprocess.</param>
+        /// <param name="variables">The variables defined prior to preprocessing.</param>
+        /// <returns>XDocument with the postprocessed data.</returns>
+        [SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes")]
+        public XDocument Process(string sourceFile, IDictionary<string, string> variables)
+        {
+            using (Stream sourceStream = new FileStream(sourceFile, FileMode.Open, FileAccess.Read, FileShare.Read))
+            {
+                InspectorCore inspectorCore = new InspectorCore();
+                foreach (InspectorExtension inspectorExtension in this.inspectorExtensions)
+                {
+                    inspectorExtension.Core = inspectorCore;
+                    inspectorExtension.InspectSource(sourceStream);
+
+                    // reset
+                    inspectorExtension.Core = null;
+                    sourceStream.Position = 0;
+                }
+
+                if (inspectorCore.EncounteredError)
+                {
+                    return null;
+                }
+
+                using (XmlReader reader = XmlReader.Create(sourceFile, DocumentXmlReaderSettings))
+                {
+                    return Process(reader, variables, sourceFile);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Preprocesses a file.
+        /// </summary>
+        /// <param name="sourceFile">The file to preprocess.</param>
+        /// <param name="variables">The variables defined prior to preprocessing.</param>
+        /// <returns>XDocument with the postprocessed data.</returns>
+        [SuppressMessage("Microsoft.Design", "CA1059:MembersShouldNotExposeCertainConcreteTypes")]
+        public XDocument Process(XmlReader reader, IDictionary<string, string> variables, string sourceFile = null)
+        {
+            if (String.IsNullOrEmpty(sourceFile) && !String.IsNullOrEmpty(reader.BaseURI))
+            {
+                Uri uri = new Uri(reader.BaseURI);
+                sourceFile = uri.AbsolutePath;
+            }
+
+            this.core = new PreprocessorCore(this.extensionsByPrefix, sourceFile, variables);
+            this.core.ResolvedVariableHandler = this.ResolvedVariable;
+            this.core.CurrentPlatform = this.currentPlatform;
+            this.currentLineNumber = new SourceLineNumber(sourceFile);
+            this.currentFileStack.Clear();
+            this.currentFileStack.Push(this.core.GetVariableValue(this.currentLineNumber, "sys", "SOURCEFILEDIR"));
+
+            // Process the reader into the output.
+            XDocument output = new XDocument();
+            try
+            {
+                foreach (PreprocessorExtension extension in this.extensions)
+                {
+                    extension.Core = this.core;
+                    extension.Initialize();
+                }
+
+                this.PreprocessReader(false, reader, output, 0);
+            }
+            catch (XmlException e)
+            {
+                this.UpdateCurrentLineNumber(reader, 0);
+                throw new WixException(WixErrors.InvalidXml(this.currentLineNumber, "source", e.Message));
+            }
+
+            // Fire event with post-processed document.
+            ProcessedStreamEventArgs args = new ProcessedStreamEventArgs(sourceFile, output);
+            this.OnProcessedStream(args);
+
+            // preprocess the generated XML Document
+            foreach (PreprocessorExtension extension in this.extensions)
+            {
+                extension.PreprocessDocument(output);
+            }
+
+            // finalize the preprocessing
+            foreach (PreprocessorExtension extension in this.extensions)
+            {
+                extension.Finish();
+                extension.Core = null;
+            }
+
+            if (this.core.EncounteredError)
+            {
+                return null;
+            }
+            else
+            {
+                if (null != this.preprocessOut)
+                {
+                    output.Save(this.preprocessOut);
+                    this.preprocessOut.Flush();
+                }
+
+                return output;
+            }
+        }
+
+        /// <summary>
+        /// Determins if string is an operator.
+        /// </summary>
+        /// <param name="operation">String to check.</param>
+        /// <returns>true if string is an operator.</returns>
+        private static bool IsOperator(string operation)
+        {
+            if (operation == null)
+            {
+                return false;
+            }
+
+            operation = operation.Trim();
+            if (0 == operation.Length)
+            {
+                return false;
+            }
+
+            if ("=" == operation ||
+                "!=" == operation ||
+                "<" == operation ||
+                "<=" == operation ||
+                ">" == operation ||
+                ">=" == operation ||
+                "~=" == operation)
+            {
+                return true;
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Determines if expression is currently inside quotes.
+        /// </summary>
+        /// <param name="expression">Expression to evaluate.</param>
+        /// <param name="index">Index to start searching in expression.</param>
+        /// <returns>true if expression is inside in quotes.</returns>
+        private static bool InsideQuotes(string expression, int index)
+        {
+            if (index == -1)
+            {
+                return false;
+            }
+
+            int numQuotes = 0;
+            int tmpIndex = 0;
+            while (-1 != (tmpIndex = expression.IndexOf('\"', tmpIndex, index - tmpIndex)))
+            {
+                numQuotes++;
+                tmpIndex++;
+            }
+
+            // found an even number of quotes before the index, so we're not inside
+            if (numQuotes % 2 == 0)
+            {
+                return false;
+            }
+
+            // found an odd number of quotes, so we are inside
+            return true;
+        }
+
+        /// <summary>
+        /// Fires an event when an ifdef/ifndef directive is processed.
+        /// </summary>
+        /// <param name="ea">ifdef/ifndef event arguments.</param>
+        private void OnIfDef(IfDefEventArgs ea)
+        {
+            if (null != this.IfDef)
+            {
+                this.IfDef(this, ea);
+            }
+        }
+
+        /// <summary>
+        /// Fires an event when an included file is processed.
+        /// </summary>
+        /// <param name="ea">Included file event arguments.</param>
+        private void OnIncludedFile(IncludedFileEventArgs ea)
+        {
+            if (null != this.IncludedFile)
+            {
+                this.IncludedFile(this, ea);
+            }
+        }
+
+        /// <summary>
+        /// Fires an event after the file is preprocessed.
+        /// </summary>
+        /// <param name="ea">Included file event arguments.</param>
+        private void OnProcessedStream(ProcessedStreamEventArgs ea)
+        {
+            if (null != this.ProcessedStream)
+            {
+                this.ProcessedStream(this, ea);
+            }
+        }
+
+        /// <summary>
+        /// Tests expression to see if it starts with a keyword.
+        /// </summary>
+        /// <param name="expression">Expression to test.</param>
+        /// <param name="operation">Operation to test for.</param>
+        /// <returns>true if expression starts with a keyword.</returns>
+        private static bool StartsWithKeyword(string expression, PreprocessorOperation operation)
+        {
+            expression = expression.ToUpper(CultureInfo.InvariantCulture);
+            switch (operation)
+            {
+                case PreprocessorOperation.Not:
+                    if (expression.StartsWith("NOT ", StringComparison.Ordinal) || expression.StartsWith("NOT(", StringComparison.Ordinal))
+                    {
+                        return true;
+                    }
+                    break;
+                case PreprocessorOperation.And:
+                    if (expression.StartsWith("AND ", StringComparison.Ordinal) || expression.StartsWith("AND(", StringComparison.Ordinal))
+                    {
+                        return true;
+                    }
+                    break;
+                case PreprocessorOperation.Or:
+                    if (expression.StartsWith("OR ", StringComparison.Ordinal) || expression.StartsWith("OR(", StringComparison.Ordinal))
+                    {
+                        return true;
+                    }
+                    break;
+                default:
+                    break;
+            }
+            return false;
+        }
+
+        /// <summary>
+        /// Processes an xml reader into an xml writer.
+        /// </summary>
+        /// <param name="include">Specifies if reader is from an included file.</param>
+        /// <param name="reader">Reader for the source document.</param>
+        /// <param name="container">Node where content should be added.</param>
+        /// <param name="offset">Original offset for the line numbers being processed.</param>
+        private void PreprocessReader(bool include, XmlReader reader, XContainer container, int offset)
+        {
+            XContainer currentContainer = container;
+            Stack<XContainer> containerStack = new Stack<XContainer>();
+
+            IfContext ifContext = new IfContext(true, true, IfState.Unknown); // start by assuming we want to keep the nodes in the source code
+            Stack<IfContext> ifStack = new Stack<IfContext>();
+
+            // process the reader into the writer
+            while (reader.Read())
+            {
+                // update information here in case an error occurs before the next read
+                this.UpdateCurrentLineNumber(reader, offset);
+
+                SourceLineNumber sourceLineNumbers = this.currentLineNumber;
+
+                // check for changes in conditional processing
+                if (XmlNodeType.ProcessingInstruction == reader.NodeType)
+                {
+                    bool ignore = false;
+                    string name = null;
+
+                    switch (reader.LocalName)
+                    {
+                        case "if":
+                            ifStack.Push(ifContext);
+                            if (ifContext.IsTrue)
+                            {
+                                ifContext = new IfContext(ifContext.IsTrue & ifContext.Active, this.EvaluateExpression(reader.Value), IfState.If);
+                            }
+                            else // Use a default IfContext object so we don't try to evaluate the expression if the context isn't true
+                            {
+                                ifContext = new IfContext();
+                            }
+                            ignore = true;
+                            break;
+
+                        case "ifdef":
+                            ifStack.Push(ifContext);
+                            name = reader.Value.Trim();
+                            if (ifContext.IsTrue)
+                            {
+                                ifContext = new IfContext(ifContext.IsTrue & ifContext.Active, (null != this.core.GetVariableValue(sourceLineNumbers, name, true)), IfState.If);
+                            }
+                            else // Use a default IfContext object so we don't try to evaluate the expression if the context isn't true
+                            {
+                                ifContext = new IfContext();
+                            }
+                            ignore = true;
+                            OnIfDef(new IfDefEventArgs(sourceLineNumbers, true, ifContext.IsTrue, name));
+                            break;
+
+                        case "ifndef":
+                            ifStack.Push(ifContext);
+                            name = reader.Value.Trim();
+                            if (ifContext.IsTrue)
+                            {
+                                ifContext = new IfContext(ifContext.IsTrue & ifContext.Active, (null == this.core.GetVariableValue(sourceLineNumbers, name, true)), IfState.If);
+                            }
+                            else // Use a default IfContext object so we don't try to evaluate the expression if the context isn't true
+                            {
+                                ifContext = new IfContext();
+                            }
+                            ignore = true;
+                            OnIfDef(new IfDefEventArgs(sourceLineNumbers, false, !ifContext.IsTrue, name));
+                            break;
+
+                        case "elseif":
+                            if (0 == ifStack.Count)
+                            {
+                                throw new WixException(WixErrors.UnmatchedPreprocessorInstruction(this.currentLineNumber, "if", "elseif"));
+                            }
+
+                            if (IfState.If != ifContext.IfState && IfState.ElseIf != ifContext.IfState)
+                            {
+                                throw new WixException(WixErrors.UnmatchedPreprocessorInstruction(this.currentLineNumber, "if", "elseif"));
+                            }
+
+                            ifContext.IfState = IfState.ElseIf;   // we're now in an elseif
+                            if (!ifContext.WasEverTrue)   // if we've never evaluated the if context to true, then we can try this test
+                            {
+                                ifContext.IsTrue = this.EvaluateExpression(reader.Value);
+                            }
+                            else if (ifContext.IsTrue)
+                            {
+                                ifContext.IsTrue = false;
+                            }
+                            ignore = true;
+                            break;
+
+                        case "else":
+                            if (0 == ifStack.Count)
+                            {
+                                throw new WixException(WixErrors.UnmatchedPreprocessorInstruction(this.currentLineNumber, "if", "else"));
+                            }
+
+                            if (IfState.If != ifContext.IfState && IfState.ElseIf != ifContext.IfState)
+                            {
+                                throw new WixException(WixErrors.UnmatchedPreprocessorInstruction(this.currentLineNumber, "if", "else"));
+                            }
+
+                            ifContext.IfState = IfState.Else;   // we're now in an else
+                            ifContext.IsTrue = !ifContext.WasEverTrue;   // if we were never true, we can be true now
+                            ignore = true;
+                            break;
+
+                        case "endif":
+                            if (0 == ifStack.Count)
+                            {
+                                throw new WixException(WixErrors.UnmatchedPreprocessorInstruction(this.currentLineNumber, "if", "endif"));
+                            }
+
+                            ifContext = (IfContext)ifStack.Pop();
+                            ignore = true;
+                            break;
+                    }
+
+                    if (ignore)   // ignore this node since we just handled it above
+                    {
+                        continue;
+                    }
+                }
+
+                if (!ifContext.Active || !ifContext.IsTrue)   // if our context is not true then skip the rest of the processing and just read the next thing
+                {
+                    continue;
+                }
+
+                switch (reader.NodeType)
+                {
+                    case XmlNodeType.XmlDeclaration:
+                        XDocument document = currentContainer as XDocument;
+                        if (null != document)
+                        {
+                            document.Declaration = new XDeclaration(null, null, null);
+                            while (reader.MoveToNextAttribute())
+                            {
+                                switch (reader.LocalName)
+                                {
+                                    case "version":
+                                        document.Declaration.Version = reader.Value;
+                                        break;
+
+                                    case "encoding":
+                                        document.Declaration.Encoding = reader.Value;
+                                        break;
+
+                                    case "standalone":
+                                        document.Declaration.Standalone = reader.Value;
+                                        break;
+                                }
+                            }
+
+                        }
+                        //else
+                        //{
+                        //    display an error? Can this happen?
+                        //}
+                        break;
+
+                    case XmlNodeType.ProcessingInstruction:
+                        switch (reader.LocalName)
+                        {
+                            case "define":
+                                this.PreprocessDefine(reader.Value);
+                                break;
+
+                            case "error":
+                                this.PreprocessError(reader.Value);
+                                break;
+
+                            case "warning":
+                                this.PreprocessWarning(reader.Value);
+                                break;
+
+                            case "undef":
+                                this.PreprocessUndef(reader.Value);
+                                break;
+
+                            case "include":
+                                this.UpdateCurrentLineNumber(reader, offset);
+                                this.PreprocessInclude(reader.Value, currentContainer);
+                                break;
+
+                            case "foreach":
+                                this.PreprocessForeach(reader, currentContainer, offset);
+                                break;
+
+                            case "endforeach": // endforeach is handled in PreprocessForeach, so seeing it here is an error
+                                throw new WixException(WixErrors.UnmatchedPreprocessorInstruction(this.currentLineNumber, "foreach", "endforeach"));
+
+                            case "pragma":
+                                this.PreprocessPragma(reader.Value, currentContainer);
+                                break;
+
+                            default:
+                                // unknown processing instructions are currently ignored
+                                break;
+                        }
+                        break;
+
+                    case XmlNodeType.Element:
+                        if (0 < this.includeNextStack.Count && this.includeNextStack.Peek())
+                        {
+                            if ("Include" != reader.LocalName)
+                            {
+                                this.core.OnMessage(WixErrors.InvalidDocumentElement(this.currentLineNumber, reader.Name, "include", "Include"));
+                            }
+
+                            this.includeNextStack.Pop();
+                            this.includeNextStack.Push(false);
+                            break;
+                        }
+
+                        bool empty = reader.IsEmptyElement;
+                        XNamespace ns = XNamespace.Get(reader.NamespaceURI);
+                        XElement element = new XElement(ns + reader.LocalName);
+                        currentContainer.Add(element);
+
+                        this.UpdateCurrentLineNumber(reader, offset);
+                        element.AddAnnotation(this.currentLineNumber);
+
+                        while (reader.MoveToNextAttribute())
+                        {
+                            string value = this.core.PreprocessString(this.currentLineNumber, reader.Value);
+                            XNamespace attribNamespace = XNamespace.Get(reader.NamespaceURI);
+                            attribNamespace = XNamespace.Xmlns == attribNamespace && reader.LocalName.Equals("xmlns") ? XNamespace.None : attribNamespace;
+                            element.Add(new XAttribute(attribNamespace + reader.LocalName, value));
+                        }
+
+                        if (!empty)
+                        {
+                            containerStack.Push(currentContainer);
+                            currentContainer = element;
+                        }
+                        break;
+
+                    case XmlNodeType.EndElement:
+                        if (0 < reader.Depth || !include)
+                        {
+                            currentContainer = containerStack.Pop();
+                        }
+                        break;
+
+                    case XmlNodeType.Text:
+                        string postprocessedText = this.core.PreprocessString(this.currentLineNumber, reader.Value);
+                        currentContainer.Add(postprocessedText);
+                        break;
+
+                    case XmlNodeType.CDATA:
+                        string postprocessedValue = this.core.PreprocessString(this.currentLineNumber, reader.Value);
+                        currentContainer.Add(new XCData(postprocessedValue));
+                        break;
+
+                    default:
+                        break;
+                }
+            }
+
+            if (0 != ifStack.Count)
+            {
+                throw new WixException(WixErrors.NonterminatedPreprocessorInstruction(this.currentLineNumber, "if", "endif"));
+            }
+
+            // TODO: can this actually happen?
+            if (0 != containerStack.Count)
+            {
+                throw new WixException(WixErrors.NonterminatedPreprocessorInstruction(this.currentLineNumber, "nodes", "nodes"));
+            }
+        }
+
+        /// <summary>
+        /// Processes an error processing instruction.
+        /// </summary>
+        /// <param name="errorMessage">Text from source.</param>
+        private void PreprocessError(string errorMessage)
+        {
+            SourceLineNumber sourceLineNumbers = this.currentLineNumber;
+
+            // resolve other variables in the error message
+            errorMessage = this.core.PreprocessString(sourceLineNumbers, errorMessage);
+
+            throw new WixException(WixErrors.PreprocessorError(sourceLineNumbers, errorMessage));
+        }
+
+        /// <summary>
+        /// Processes a warning processing instruction.
+        /// </summary>
+        /// <param name="warningMessage">Text from source.</param>
+        private void PreprocessWarning(string warningMessage)
+        {
+            SourceLineNumber sourceLineNumbers = this.currentLineNumber;
+
+            // resolve other variables in the warning message
+            warningMessage = this.core.PreprocessString(sourceLineNumbers, warningMessage);
+
+            this.core.OnMessage(WixWarnings.PreprocessorWarning(sourceLineNumbers, warningMessage));
+        }
+
+        /// <summary>
+        /// Processes a define processing instruction and creates the appropriate parameter.
+        /// </summary>
+        /// <param name="originalDefine">Text from source.</param>
+        private void PreprocessDefine(string originalDefine)
+        {
+            Match match = defineRegex.Match(originalDefine);
+            SourceLineNumber sourceLineNumbers = this.currentLineNumber;
+
+            if (!match.Success)
+            {
+                throw new WixException(WixErrors.IllegalDefineStatement(sourceLineNumbers, originalDefine));
+            }
+
+            string defineName = match.Groups["varName"].Value;
+            string defineValue = match.Groups["varValue"].Value;
+
+            // strip off the optional quotes
+            if (1 < defineValue.Length &&
+                   ((defineValue.StartsWith("\"", StringComparison.Ordinal) && defineValue.EndsWith("\"", StringComparison.Ordinal))
+                || (defineValue.StartsWith("'", StringComparison.Ordinal) && defineValue.EndsWith("'", StringComparison.Ordinal))))
+            {
+                defineValue = defineValue.Substring(1, defineValue.Length - 2);
+            }
+
+            // resolve other variables in the variable value
+            defineValue = this.core.PreprocessString(sourceLineNumbers, defineValue);
+
+            if (defineName.StartsWith("var.", StringComparison.Ordinal))
+            {
+                this.core.AddVariable(sourceLineNumbers, defineName.Substring(4), defineValue);
+            }
+            else
+            {
+                this.core.AddVariable(sourceLineNumbers, defineName, defineValue);
+            }
+        }
+
+        /// <summary>
+        /// Processes an undef processing instruction and creates the appropriate parameter.
+        /// </summary>
+        /// <param name="originalDefine">Text from source.</param>
+        private void PreprocessUndef(string originalDefine)
+        {
+            SourceLineNumber sourceLineNumbers = this.currentLineNumber;
+            string name = this.core.PreprocessString(sourceLineNumbers, originalDefine.Trim());
+
+            if (name.StartsWith("var.", StringComparison.Ordinal))
+            {
+                this.core.RemoveVariable(sourceLineNumbers, name.Substring(4));
+            }
+            else
+            {
+                this.core.RemoveVariable(sourceLineNumbers, name);
+            }
+        }
+
+        /// <summary>
+        /// Processes an included file.
+        /// </summary>
+        /// <param name="includePath">Path to included file.</param>
+        /// <param name="parent">Parent container for included content.</param>
+        private void PreprocessInclude(string includePath, XContainer parent)
+        {
+            SourceLineNumber sourceLineNumbers = this.currentLineNumber;
+
+            // preprocess variables in the path
+            includePath = this.core.PreprocessString(sourceLineNumbers, includePath);
+
+            string includeFile = this.GetIncludeFile(includePath);
+
+            if (null == includeFile)
+            {
+                throw new WixException(WixErrors.FileNotFound(sourceLineNumbers, includePath, "include"));
+            }
+
+            using (XmlReader reader = XmlReader.Create(includeFile, DocumentXmlReaderSettings))
+            {
+                this.PushInclude(includeFile);
+
+                // process the included reader into the writer
+                try
+                {
+                    this.PreprocessReader(true, reader, parent, 0);
+                }
+                catch (XmlException e)
+                {
+                    this.UpdateCurrentLineNumber(reader, 0);
+                    throw new WixException(WixErrors.InvalidXml(sourceLineNumbers, "source", e.Message));
+                }
+
+                this.OnIncludedFile(new IncludedFileEventArgs(sourceLineNumbers, includeFile));
+
+                this.PopInclude();
+            }
+        }
+
+        /// <summary>
+        /// Preprocess a foreach processing instruction.
+        /// </summary>
+        /// <param name="reader">The xml reader.</param>
+        /// <param name="container">The container where to output processed data.</param>
+        /// <param name="offset">Offset for the line numbers.</param>
+        private void PreprocessForeach(XmlReader reader, XContainer container, int offset)
+        {
+            // find the "in" token
+            int indexOfInToken = reader.Value.IndexOf(" in ", StringComparison.Ordinal);
+            if (0 > indexOfInToken)
+            {
+                throw new WixException(WixErrors.IllegalForeach(this.currentLineNumber, reader.Value));
+            }
+
+            // parse out the variable name
+            string varName = reader.Value.Substring(0, indexOfInToken).Trim();
+            string varValuesString = reader.Value.Substring(indexOfInToken + 4).Trim();
+
+            // preprocess the variable values string because it might be a variable itself
+            varValuesString = this.core.PreprocessString(this.currentLineNumber, varValuesString);
+
+            string[] varValues = varValuesString.Split(';');
+
+            // go through all the empty strings
+            while (reader.Read() && XmlNodeType.Whitespace == reader.NodeType)
+            {
+            }
+
+            // get the offset of this xml fragment (for some reason its always off by 1)
+            IXmlLineInfo lineInfoReader = reader as IXmlLineInfo;
+            if (null != lineInfoReader)
+            {
+                offset += lineInfoReader.LineNumber - 1;
+            }
+
+            XmlTextReader textReader = reader as XmlTextReader;
+            // dump the xml to a string (maintaining whitespace if possible)
+            if (null != textReader)
+            {
+                textReader.WhitespaceHandling = WhitespaceHandling.All;
+            }
+
+            StringBuilder fragmentBuilder = new StringBuilder();
+            int nestedForeachCount = 1;
+            while (nestedForeachCount != 0)
+            {
+                if (reader.NodeType == XmlNodeType.ProcessingInstruction)
+                {
+                    switch (reader.LocalName)
+                    {
+                        case "foreach":
+                            ++nestedForeachCount;
+                            // Output the foreach statement
+                            fragmentBuilder.AppendFormat("<?foreach {0}?>", reader.Value);
+                            break;
+
+                        case "endforeach":
+                            --nestedForeachCount;
+                            if (0 != nestedForeachCount)
+                            {
+                                fragmentBuilder.Append("<?endforeach ?>");
+                            }
+                            break;
+
+                        default:
+                            fragmentBuilder.AppendFormat("<?{0} {1}?>", reader.LocalName, reader.Value);
+                            break;
+                    }
+                }
+                else if (reader.NodeType == XmlNodeType.Element)
+                {
+                    fragmentBuilder.Append(reader.ReadOuterXml());
+                    continue;
+                }
+                else if (reader.NodeType == XmlNodeType.Whitespace)
+                {
+                    // Or output the whitespace
+                    fragmentBuilder.Append(reader.Value);
+                }
+                else if (reader.NodeType == XmlNodeType.None)
+                {
+                    throw new WixException(WixErrors.ExpectedEndforeach(this.currentLineNumber));
+                }
+
+                reader.Read();
+            }
+
+            using (MemoryStream fragmentStream = new MemoryStream(Encoding.UTF8.GetBytes(fragmentBuilder.ToString())))
+            using (XmlReader loopReader = XmlReader.Create(fragmentStream, FragmentXmlReaderSettings))
+            {
+                // process each iteration, updating the variable's value each time
+                foreach (string varValue in varValues)
+                {
+                    // Always overwrite foreach variables.
+                    this.core.AddVariable(this.currentLineNumber, varName, varValue, false);
+
+                    try
+                    {
+                        this.PreprocessReader(false, loopReader, container, offset);
+                    }
+                    catch (XmlException e)
+                    {
+                        this.UpdateCurrentLineNumber(loopReader, offset);
+                        throw new WixException(WixErrors.InvalidXml(this.currentLineNumber, "source", e.Message));
+                    }
+
+                    fragmentStream.Position = 0; // seek back to the beginning for the next loop.
+                }
+            }
+        }
+
+        /// <summary>
+        /// Processes a pragma processing instruction
+        /// </summary>
+        /// <param name="pragmaText">Text from source.</param>
+        private void PreprocessPragma(string pragmaText, XContainer parent)
+        {
+            Match match = pragmaRegex.Match(pragmaText);
+            SourceLineNumber sourceLineNumbers = this.currentLineNumber;
+
+            if (!match.Success)
+            {
+                throw new WixException(WixErrors.InvalidPreprocessorPragma(sourceLineNumbers, pragmaText));
+            }
+
+            // resolve other variables in the pragma argument(s)
+            string pragmaArgs = this.core.PreprocessString(sourceLineNumbers, match.Groups["pragmaValue"].Value).Trim();
+
+            try
+            {
+                this.core.PreprocessPragma(sourceLineNumbers, match.Groups["pragmaName"].Value.Trim(), pragmaArgs, parent);
+            }
+            catch (Exception e)
+            {
+                throw new WixException(WixErrors.PreprocessorExtensionPragmaFailed(sourceLineNumbers, pragmaText, e.Message));
+            }
+        }
+
+        /// <summary>
+        /// Gets the next token in an expression.
+        /// </summary>
+        /// <param name="originalExpression">Expression to parse.</param>
+        /// <param name="expression">Expression with token removed.</param>
+        /// <param name="stringLiteral">Flag if token is a string literal instead of a variable.</param>
+        /// <returns>Next token.</returns>
+        private string GetNextToken(string originalExpression, ref string expression, out bool stringLiteral)
+        {
+            stringLiteral = false;
+            string token = String.Empty;
+            expression = expression.Trim();
+            if (0 == expression.Length)
+            {
+                return String.Empty;
+            }
+
+            if (expression.StartsWith("\"", StringComparison.Ordinal))
+            {
+                stringLiteral = true;
+                int endingQuotes = expression.IndexOf('\"', 1);
+                if (-1 == endingQuotes)
+                {
+                    throw new WixException(WixErrors.UnmatchedQuotesInExpression(this.currentLineNumber, originalExpression));
+                }
+
+                // cut the quotes off the string
+                token = this.core.PreprocessString(this.currentLineNumber, expression.Substring(1, endingQuotes - 1));
+
+                // advance past this string
+                expression = expression.Substring(endingQuotes + 1).Trim();
+            }
+            else if (expression.StartsWith("$(", StringComparison.Ordinal))
+            {
+                // Find the ending paren of the expression
+                int endingParen = -1;
+                int openedCount = 1;
+                for (int i = 2; i < expression.Length; i++)
+                {
+                    if ('(' == expression[i])
+                    {
+                        openedCount++;
+                    }
+                    else if (')' == expression[i])
+                    {
+                        openedCount--;
+                    }
+
+                    if (openedCount == 0)
+                    {
+                        endingParen = i;
+                        break;
+                    }
+                }
+
+                if (-1 == endingParen)
+                {
+                    throw new WixException(WixErrors.UnmatchedParenthesisInExpression(this.currentLineNumber, originalExpression));
+                }
+                token = expression.Substring(0, endingParen + 1);
+
+                // Advance past this variable
+                expression = expression.Substring(endingParen + 1).Trim();
+            }
+            else
+            {
+                // Cut the token off at the next equal, space, inequality operator,
+                // or end of string, whichever comes first
+                int space = expression.IndexOf(" ", StringComparison.Ordinal);
+                int equals = expression.IndexOf("=", StringComparison.Ordinal);
+                int lessThan = expression.IndexOf("<", StringComparison.Ordinal);
+                int lessThanEquals = expression.IndexOf("<=", StringComparison.Ordinal);
+                int greaterThan = expression.IndexOf(">", StringComparison.Ordinal);
+                int greaterThanEquals = expression.IndexOf(">=", StringComparison.Ordinal);
+                int notEquals = expression.IndexOf("!=", StringComparison.Ordinal);
+                int equalsNoCase = expression.IndexOf("~=", StringComparison.Ordinal);
+                int closingIndex;
+
+                if (space == -1)
+                {
+                    space = Int32.MaxValue;
+                }
+
+                if (equals == -1)
+                {
+                    equals = Int32.MaxValue;
+                }
+
+                if (lessThan == -1)
+                {
+                    lessThan = Int32.MaxValue;
+                }
+
+                if (lessThanEquals == -1)
+                {
+                    lessThanEquals = Int32.MaxValue;
+                }
+
+                if (greaterThan == -1)
+                {
+                    greaterThan = Int32.MaxValue;
+                }
+
+                if (greaterThanEquals == -1)
+                {
+                    greaterThanEquals = Int32.MaxValue;
+                }
+
+                if (notEquals == -1)
+                {
+                    notEquals = Int32.MaxValue;
+                }
+
+                if (equalsNoCase == -1)
+                {
+                    equalsNoCase = Int32.MaxValue;
+                }
+
+                closingIndex = Math.Min(space, Math.Min(equals, Math.Min(lessThan, Math.Min(lessThanEquals, Math.Min(greaterThan, Math.Min(greaterThanEquals, Math.Min(equalsNoCase, notEquals)))))));
+
+                if (Int32.MaxValue == closingIndex)
+                {
+                    closingIndex = expression.Length;
+                }
+
+                // If the index is 0, we hit an operator, so return it
+                if (0 == closingIndex)
+                {
+                    // Length 2 operators
+                    if (closingIndex == lessThanEquals || closingIndex == greaterThanEquals || closingIndex == notEquals || closingIndex == equalsNoCase)
+                    {
+                        closingIndex = 2;
+                    }
+                    else // Length 1 operators
+                    {
+                        closingIndex = 1;
+                    }
+                }
+
+                // Cut out the new token
+                token = expression.Substring(0, closingIndex).Trim();
+                expression = expression.Substring(closingIndex).Trim();
+            }
+
+            return token;
+        }
+
+        /// <summary>
+        /// Gets the value for a variable.
+        /// </summary>
+        /// <param name="originalExpression">Original expression for error message.</param>
+        /// <param name="variable">Variable to evaluate.</param>
+        /// <returns>Value of variable.</returns>
+        private string EvaluateVariable(string originalExpression, string variable)
+        {
+            // By default it's a literal and will only be evaluated if it
+            // matches the variable format
+            string varValue = variable;
+
+            if (variable.StartsWith("$(", StringComparison.Ordinal))
+            {
+                try
+                {
+                    varValue = this.core.PreprocessString(this.currentLineNumber, variable);
+                }
+                catch (ArgumentNullException)
+                {
+                    // non-existent variables are expected
+                    varValue = null;
+                }
+            }
+            else if (variable.IndexOf("(", StringComparison.Ordinal) != -1 || variable.IndexOf(")", StringComparison.Ordinal) != -1)
+            {
+                // make sure it doesn't contain parenthesis
+                throw new WixException(WixErrors.UnmatchedParenthesisInExpression(this.currentLineNumber, originalExpression));
+            }
+            else if (variable.IndexOf("\"", StringComparison.Ordinal) != -1)
+            {
+                // shouldn't contain quotes
+                throw new WixException(WixErrors.UnmatchedQuotesInExpression(this.currentLineNumber, originalExpression));
+            }
+
+            return varValue;
+        }
+
+        /// <summary>
+        /// Gets the left side value, operator, and right side value of an expression.
+        /// </summary>
+        /// <param name="originalExpression">Original expression to evaluate.</param>
+        /// <param name="expression">Expression modified while processing.</param>
+        /// <param name="leftValue">Left side value from expression.</param>
+        /// <param name="operation">Operation in expression.</param>
+        /// <param name="rightValue">Right side value from expression.</param>
+        private void GetNameValuePair(string originalExpression, ref string expression, out string leftValue, out string operation, out string rightValue)
+        {
+            bool stringLiteral;
+            leftValue = this.GetNextToken(originalExpression, ref expression, out stringLiteral);
+
+            // If it wasn't a string literal, evaluate it
+            if (!stringLiteral)
+            {
+                leftValue = this.EvaluateVariable(originalExpression, leftValue);
+            }
+
+            // Get the operation
+            operation = this.GetNextToken(originalExpression, ref expression, out stringLiteral);
+            if (IsOperator(operation))
+            {
+                if (stringLiteral)
+                {
+                    throw new WixException(WixErrors.UnmatchedQuotesInExpression(this.currentLineNumber, originalExpression));
+                }
+
+                rightValue = this.GetNextToken(originalExpression, ref expression, out stringLiteral);
+
+                // If it wasn't a string literal, evaluate it
+                if (!stringLiteral)
+                {
+                    rightValue = this.EvaluateVariable(originalExpression, rightValue);
+                }
+            }
+            else
+            {
+                // Prepend the token back on the expression since it wasn't an operator
+                // and put the quotes back on the literal if necessary
+
+                if (stringLiteral)
+                {
+                    operation = "\"" + operation + "\"";
+                }
+                expression = (operation + " " + expression).Trim();
+
+                // If no operator, just check for existence
+                operation = "";
+                rightValue = "";
+            }
+        }
+
+        /// <summary>
+        /// Evaluates an expression.
+        /// </summary>
+        /// <param name="originalExpression">Original expression to evaluate.</param>
+        /// <param name="expression">Expression modified while processing.</param>
+        /// <returns>true if expression evaluates to true.</returns>
+        private bool EvaluateAtomicExpression(string originalExpression, ref string expression)
+        {
+            // Quick test to see if the first token is a variable
+            bool startsWithVariable = expression.StartsWith("$(", StringComparison.Ordinal);
+
+            string leftValue;
+            string rightValue;
+            string operation;
+            this.GetNameValuePair(originalExpression, ref expression, out leftValue, out operation, out rightValue);
+
+            bool expressionValue = false;
+
+            // If the variables don't exist, they were evaluated to null
+            if (null == leftValue || null == rightValue)
+            {
+                if (operation.Length > 0)
+                {
+                    throw new WixException(WixErrors.ExpectedVariable(this.currentLineNumber, originalExpression));
+                }
+
+                // false expression
+            }
+            else if (operation.Length == 0)
+            {
+                // There is no right side of the equation.
+                // If the variable was evaluated, it exists, so the expression is true
+                if (startsWithVariable)
+                {
+                    expressionValue = true;
+                }
+                else
+                {
+                    throw new WixException(WixErrors.UnexpectedLiteral(this.currentLineNumber, originalExpression));
+                }
+            }
+            else
+            {
+                leftValue = leftValue.Trim();
+                rightValue = rightValue.Trim();
+                if ("=" == operation)
+                {
+                    if (leftValue == rightValue)
+                    {
+                        expressionValue = true;
+                    }
+                }
+                else if ("!=" == operation)
+                {
+                    if (leftValue != rightValue)
+                    {
+                        expressionValue = true;
+                    }
+                }
+                else if ("~=" == operation)
+                {
+                    if (String.Equals(leftValue, rightValue, StringComparison.OrdinalIgnoreCase))
+                    {
+                        expressionValue = true;
+                    }
+                }
+                else
+                {
+                    // Convert the numbers from strings
+                    int rightInt;
+                    int leftInt;
+                    try
+                    {
+                        rightInt = Int32.Parse(rightValue, CultureInfo.InvariantCulture);
+                        leftInt = Int32.Parse(leftValue, CultureInfo.InvariantCulture);
+                    }
+                    catch (FormatException)
+                    {
+                        throw new WixException(WixErrors.IllegalIntegerInExpression(this.currentLineNumber, originalExpression));
+                    }
+                    catch (OverflowException)
+                    {
+                        throw new WixException(WixErrors.IllegalIntegerInExpression(this.currentLineNumber, originalExpression));
+                    }
+
+                    // Compare the numbers
+                    if ("<" == operation && leftInt < rightInt ||
+                        "<=" == operation && leftInt <= rightInt ||
+                        ">" == operation && leftInt > rightInt ||
+                        ">=" == operation && leftInt >= rightInt)
+                    {
+                        expressionValue = true;
+                    }
+                }
+            }
+
+            return expressionValue;
+        }
+
+        /// <summary>
+        /// Gets a sub-expression in parenthesis.
+        /// </summary>
+        /// <param name="originalExpression">Original expression to evaluate.</param>
+        /// <param name="expression">Expression modified while processing.</param>
+        /// <param name="endSubExpression">Index of end of sub-expression.</param>
+        /// <returns>Sub-expression in parenthesis.</returns>
+        private string GetParenthesisExpression(string originalExpression, string expression, out int endSubExpression)
+        {
+            endSubExpression = 0;
+
+            // if the expression doesn't start with parenthesis, leave it alone
+            if (!expression.StartsWith("(", StringComparison.Ordinal))
+            {
+                return expression;
+            }
+
+            // search for the end of the expression with the matching paren
+            int openParenIndex = 0;
+            int closeParenIndex = 1;
+            while (openParenIndex != -1 && openParenIndex < closeParenIndex)
+            {
+                closeParenIndex = expression.IndexOf(')', closeParenIndex);
+                if (closeParenIndex == -1)
+                {
+                    throw new WixException(WixErrors.UnmatchedParenthesisInExpression(this.currentLineNumber, originalExpression));
+                }
+
+                if (InsideQuotes(expression, closeParenIndex))
+                {
+                    // ignore stuff inside quotes (it's a string literal)
+                }
+                else
+                {
+                    // Look to see if there is another open paren before the close paren
+                    // and skip over the open parens while they are in a string literal
+                    do
+                    {
+                        openParenIndex++;
+                        openParenIndex = expression.IndexOf('(', openParenIndex, closeParenIndex - openParenIndex);
+                    }
+                    while (InsideQuotes(expression, openParenIndex));
+                }
+
+                // Advance past the closing paren
+                closeParenIndex++;
+            }
+
+            endSubExpression = closeParenIndex;
+
+            // Return the expression minus the parenthesis
+            return expression.Substring(1, closeParenIndex - 2);
+        }
+
+        /// <summary>
+        /// Updates expression based on operation.
+        /// </summary>
+        /// <param name="currentValue">State to update.</param>
+        /// <param name="operation">Operation to apply to current value.</param>
+        /// <param name="prevResult">Previous result.</param>
+        private void UpdateExpressionValue(ref bool currentValue, PreprocessorOperation operation, bool prevResult)
+        {
+            switch (operation)
+            {
+                case PreprocessorOperation.And:
+                    currentValue = currentValue && prevResult;
+                    break;
+                case PreprocessorOperation.Or:
+                    currentValue = currentValue || prevResult;
+                    break;
+                case PreprocessorOperation.Not:
+                    currentValue = !currentValue;
+                    break;
+                default:
+                    throw new WixException(WixErrors.UnexpectedPreprocessorOperator(this.currentLineNumber, operation.ToString()));
+            }
+        }
+
+        /// <summary>
+        /// Evaluate an expression.
+        /// </summary>
+        /// <param name="expression">Expression to evaluate.</param>
+        /// <returns>Boolean result of expression.</returns>
+        private bool EvaluateExpression(string expression)
+        {
+            string tmpExpression = expression;
+            return this.EvaluateExpressionRecurse(expression, ref tmpExpression, PreprocessorOperation.And, true);
+        }
+
+        /// <summary>
+        /// Recurse through the expression to evaluate if it is true or false.
+        /// The expression is evaluated left to right. 
+        /// The expression is case-sensitive (converted to upper case) with the
+        /// following exceptions: variable names and keywords (and, not, or).
+        /// Comparisons with = and != are string comparisons.  
+        /// Comparisons with inequality operators must be done on valid integers.
+        /// 
+        /// The operator precedence is:
+        ///    ""
+        ///    ()
+        ///    &lt;, &gt;, &lt;=, &gt;=, =, !=
+        ///    Not
+        ///    And, Or
+        ///    
+        /// Valid expressions include:
+        ///   not $(var.B) or not $(var.C)
+        ///   (($(var.A))and $(var.B) ="2")or Not((($(var.C))) and $(var.A))
+        ///   (($(var.A)) and $(var.B) = " 3 ") or $(var.C)
+        ///   $(var.A) and $(var.C) = "3" or $(var.C) and $(var.D) = $(env.windir)
+        ///   $(var.A) and $(var.B)>2 or $(var.B) &lt;= 2
+        ///   $(var.A) != "2" 
+        /// </summary>
+        /// <param name="originalExpression">The original expression</param>
+        /// <param name="expression">The expression currently being evaluated</param>
+        /// <param name="prevResultOperation">The operation to apply to this result</param>
+        /// <param name="prevResult">The previous result to apply to this result</param>
+        /// <returns>Boolean to indicate if the expression is true or false</returns>
+        private bool EvaluateExpressionRecurse(string originalExpression, ref string expression, PreprocessorOperation prevResultOperation, bool prevResult)
+        {
+            bool expressionValue = false;
+            expression = expression.Trim();
+            if (expression.Length == 0)
+            {
+                throw new WixException(WixErrors.UnexpectedEmptySubexpression(this.currentLineNumber, originalExpression));
+            }
+
+            // If the expression starts with parenthesis, evaluate it
+            if (expression.IndexOf('(') == 0)
+            {
+                int endSubExpressionIndex;
+                string subExpression = this.GetParenthesisExpression(originalExpression, expression, out endSubExpressionIndex);
+                expressionValue = this.EvaluateExpressionRecurse(originalExpression, ref subExpression, PreprocessorOperation.And, true);
+
+                // Now get the rest of the expression that hasn't been evaluated
+                expression = expression.Substring(endSubExpressionIndex).Trim();
+            }
+            else
+            {
+                // Check for NOT
+                if (StartsWithKeyword(expression, PreprocessorOperation.Not))
+                {
+                    expression = expression.Substring(3).Trim();
+                    if (expression.Length == 0)
+                    {
+                        throw new WixException(WixErrors.ExpectedExpressionAfterNot(this.currentLineNumber, originalExpression));
+                    }
+
+                    expressionValue = this.EvaluateExpressionRecurse(originalExpression, ref expression, PreprocessorOperation.Not, true);
+                }
+                else // Expect a literal
+                {
+                    expressionValue = this.EvaluateAtomicExpression(originalExpression, ref expression);
+
+                    // Expect the literal that was just evaluated to already be cut off
+                }
+            }
+            this.UpdateExpressionValue(ref expressionValue, prevResultOperation, prevResult);
+
+            // If there's still an expression left, it must start with AND or OR.
+            if (expression.Trim().Length > 0)
+            {
+                if (StartsWithKeyword(expression, PreprocessorOperation.And))
+                {
+                    expression = expression.Substring(3);
+                    return this.EvaluateExpressionRecurse(originalExpression, ref expression, PreprocessorOperation.And, expressionValue);
+                }
+                else if (StartsWithKeyword(expression, PreprocessorOperation.Or))
+                {
+                    expression = expression.Substring(2);
+                    return this.EvaluateExpressionRecurse(originalExpression, ref expression, PreprocessorOperation.Or, expressionValue);
+                }
+                else
+                {
+                    throw new WixException(WixErrors.InvalidSubExpression(this.currentLineNumber, expression, originalExpression));
+                }
+            }
+
+            return expressionValue;
+        }
+
+        /// <summary>
+        /// Update the current line number with the reader's current state.
+        /// </summary>
+        /// <param name="reader">The xml reader for the preprocessor.</param>
+        /// <param name="offset">This is the artificial offset of the line numbers from the reader.  Used for the foreach processing.</param>
+        private void UpdateCurrentLineNumber(XmlReader reader, int offset)
+        {
+            IXmlLineInfo lineInfoReader = reader as IXmlLineInfo;
+            if (null != lineInfoReader)
+            {
+                int newLine = lineInfoReader.LineNumber + offset;
+
+                if (this.currentLineNumber.LineNumber != newLine)
+                {
+                    this.currentLineNumber = new SourceLineNumber(this.currentLineNumber.FileName, newLine);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Pushes a file name on the stack of included files.
+        /// </summary>
+        /// <param name="fileName">Name to push on to the stack of included files.</param>
+        private void PushInclude(string fileName)
+        {
+            if (1023 < this.currentFileStack.Count)
+            {
+                throw new WixException(WixErrors.TooDeeplyIncluded(this.currentLineNumber, this.currentFileStack.Count));
+            }
+
+            this.currentFileStack.Push(fileName);
+            this.sourceStack.Push(this.currentLineNumber);
+            this.currentLineNumber = new SourceLineNumber(fileName);
+            this.includeNextStack.Push(true);
+        }
+
+        /// <summary>
+        /// Pops a file name from the stack of included files.
+        /// </summary>
+        private void PopInclude()
+        {
+            this.currentLineNumber = this.sourceStack.Pop();
+
+            this.currentFileStack.Pop();
+            this.includeNextStack.Pop();
+        }
+
+        /// <summary>
+        /// Go through search paths, looking for a matching include file.
+        /// Start the search in the directory of the source file, then go
+        /// through the search paths in the order given on the command line
+        /// (leftmost first, ...).
+        /// </summary>
+        /// <param name="includePath">User-specified path to the included file (usually just the file name).</param>
+        /// <returns>Returns a FileInfo for the found include file, or null if the file cannot be found.</returns>
+        private string GetIncludeFile(string includePath)
+        {
+            string finalIncludePath = null;
+
+            includePath = includePath.Trim();
+
+            // remove quotes (only if they match)
+            if ((includePath.StartsWith("\"", StringComparison.Ordinal) && includePath.EndsWith("\"", StringComparison.Ordinal)) ||
+                (includePath.StartsWith("'", StringComparison.Ordinal) && includePath.EndsWith("'", StringComparison.Ordinal)))
+            {
+                includePath = includePath.Substring(1, includePath.Length - 2);
+            }
+
+            // check if the include file is a full path
+            if (Path.IsPathRooted(includePath))
+            {
+                if (File.Exists(includePath))
+                {
+                    finalIncludePath = includePath;
+                }
+            }
+            else // relative path
+            {
+                // build a string to test the directory containing the source file first
+                string currentFolder = this.currentFileStack.Peek();
+                string includeTestPath = Path.Combine(Path.GetDirectoryName(currentFolder) ?? String.Empty, includePath);
+
+                // test the source file directory
+                if (File.Exists(includeTestPath))
+                {
+                    finalIncludePath = includeTestPath;
+                }
+                else // test all search paths in the order specified on the command line
+                {
+                    foreach (string includeSearchPath in this.IncludeSearchPaths)
+                    {
+                        // if the path exists, we have found the final string
+                        includeTestPath = Path.Combine(includeSearchPath, includePath);
+                        if (File.Exists(includeTestPath))
+                        {
+                            finalIncludePath = includeTestPath;
+                            break;
+                        }
+                    }
+                }
+            }
+
+            return finalIncludePath;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/PreprocessorCore.cs b/src/WixToolset.Core/PreprocessorCore.cs
new file mode 100644
index 00000000..b58fc80c
--- /dev/null
+++ b/src/WixToolset.Core/PreprocessorCore.cs
@@ -0,0 +1,560 @@
+// 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
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Text;
+    using System.Xml.Linq;
+    using WixToolset.Data;
+    using WixToolset.Extensibility;
+
+    /// <summary>
+    /// The preprocessor core.
+    /// </summary>
+    internal class PreprocessorCore : IPreprocessorCore
+    {
+        private static readonly char[] variableSplitter = new char[] { '.' };
+        private static readonly char[] argumentSplitter = new char[] { ',' };
+
+        private Platform currentPlatform;
+        private Dictionary<string, IPreprocessorExtension> extensionsByPrefix;
+        private string sourceFile;
+        private IDictionary<string, string> variables;
+
+        /// <summary>
+        /// Instantiate a new PreprocessorCore.
+        /// </summary>
+        /// <param name="extensionsByPrefix">The extensions indexed by their prefixes.</param>
+        /// <param name="messageHandler">The message handler.</param>
+        /// <param name="sourceFile">The source file being preprocessed.</param>
+        /// <param name="variables">The variables defined prior to preprocessing.</param>
+        internal PreprocessorCore(Dictionary<string, IPreprocessorExtension> extensionsByPrefix, string sourceFile, IDictionary<string, string> variables)
+        {
+            this.extensionsByPrefix = extensionsByPrefix;
+            this.sourceFile = String.IsNullOrEmpty(sourceFile) ? null : Path.GetFullPath(sourceFile);
+
+            this.variables = new Dictionary<string, string>();
+            foreach (var entry in variables)
+            {
+                this.AddVariable(null, entry.Key, entry.Value);
+            }
+        }
+
+        /// <summary>
+        /// Event for resolved variables.
+        /// </summary>
+        private event ResolvedVariableEventHandler ResolvedVariable;
+
+        /// <summary>
+        /// Sets event for ResolvedVariableEventHandler.
+        /// </summary>
+        public ResolvedVariableEventHandler ResolvedVariableHandler
+        {
+            set { this.ResolvedVariable = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the platform which the compiler will use when defaulting 64-bit attributes and elements.
+        /// </summary>
+        /// <value>The platform which the compiler will use when defaulting 64-bit attributes and elements.</value>
+        public Platform CurrentPlatform
+        {
+            get { return this.currentPlatform; }
+            set { this.currentPlatform = value; }
+        }
+
+        /// <summary>
+        /// Gets whether the core encountered an error while processing.
+        /// </summary>
+        /// <value>Flag if core encountered an error during processing.</value>
+        public bool EncounteredError
+        {
+            get { return Messaging.Instance.EncounteredError; }
+        }
+
+        /// <summary>
+        /// Replaces parameters in the source text.
+        /// </summary>
+        /// <param name="sourceLineNumbers">The source line information for the function.</param>
+        /// <param name="value">Text that may contain parameters to replace.</param>
+        /// <returns>Text after parameters have been replaced.</returns>
+        public string PreprocessString(SourceLineNumber sourceLineNumbers, string value)
+        {
+            StringBuilder sb = new StringBuilder();
+            int currentPosition = 0;
+            int end = 0;
+
+            while (-1 != (currentPosition = value.IndexOf('$', end)))
+            {
+                if (end < currentPosition)
+                {
+                    sb.Append(value, end, currentPosition - end);
+                }
+
+                end = currentPosition + 1;
+                string remainder = value.Substring(end);
+                if (remainder.StartsWith("$", StringComparison.Ordinal))
+                {
+                    sb.Append("$");
+                    end++;
+                }
+                else if (remainder.StartsWith("(loc.", StringComparison.Ordinal))
+                {
+                    currentPosition = remainder.IndexOf(')');
+                    if (-1 == currentPosition)
+                    {
+                        this.OnMessage(WixErrors.InvalidPreprocessorVariable(sourceLineNumbers, remainder));
+                        break;
+                    }
+
+                    sb.Append("$");   // just put the resource reference back as was
+                    sb.Append(remainder, 0, currentPosition + 1);
+
+                    end += currentPosition + 1;
+                }
+                else if (remainder.StartsWith("(", StringComparison.Ordinal))
+                {
+                    int openParenCount = 1;
+                    int closingParenCount = 0;
+                    bool isFunction = false;
+                    bool foundClosingParen = false;
+
+                    // find the closing paren
+                    int closingParenPosition;
+                    for (closingParenPosition = 1; closingParenPosition < remainder.Length; closingParenPosition++)
+                    {
+                        switch (remainder[closingParenPosition])
+                        {
+                            case '(':
+                                openParenCount++;
+                                isFunction = true;
+                                break;
+                            case ')':
+                                closingParenCount++;
+                                break;
+                        }
+                        if (openParenCount == closingParenCount)
+                        {
+                            foundClosingParen = true;
+                            break;
+                        }
+                    }
+
+                    // move the currentPosition to the closing paren
+                    currentPosition += closingParenPosition;
+
+                    if (!foundClosingParen)
+                    {
+                        if (isFunction)
+                        {
+                            this.OnMessage(WixErrors.InvalidPreprocessorFunction(sourceLineNumbers, remainder));
+                            break;
+                        }
+                        else
+                        {
+                            this.OnMessage(WixErrors.InvalidPreprocessorVariable(sourceLineNumbers, remainder));
+                            break;
+                        }
+                    }
+
+                    string subString = remainder.Substring(1, closingParenPosition - 1);
+                    string result = null;
+                    if (isFunction)
+                    {
+                        result = this.EvaluateFunction(sourceLineNumbers, subString);
+                    }
+                    else
+                    {
+                        result = this.GetVariableValue(sourceLineNumbers, subString, false);
+                    }
+
+                    if (null == result)
+                    {
+                        if (isFunction)
+                        {
+                            this.OnMessage(WixErrors.UndefinedPreprocessorFunction(sourceLineNumbers, subString));
+                            break;
+                        }
+                        else
+                        {
+                            this.OnMessage(WixErrors.UndefinedPreprocessorVariable(sourceLineNumbers, subString));
+                            break;
+                        }
+                    }
+                    else
+                    {
+                        if (!isFunction)
+                        {
+                            this.OnResolvedVariable(new ResolvedVariableEventArgs(sourceLineNumbers, subString, result));
+                        }
+                    }
+                    sb.Append(result);
+                    end += closingParenPosition + 1;
+                }
+                else   // just a floating "$" so put it in the final string (i.e. leave it alone) and keep processing
+                {
+                    sb.Append('$');
+                }
+            }
+
+            if (end < value.Length)
+            {
+                sb.Append(value.Substring(end));
+            }
+
+            return sb.ToString();
+        }
+
+        /// <summary>
+        /// Evaluate a Pragma.
+        /// </summary>
+        /// <param name="sourceLineNumbers">The source line information for the function.</param>
+        /// <param name="pragmaName">The pragma's full name (<prefix>.<pragma>).</param>
+        /// <param name="args">The arguments to the pragma.</param>
+        /// <param name="parent">The parent element of the pragma.</param>
+        public void PreprocessPragma(SourceLineNumber sourceLineNumbers, string pragmaName, string args, XContainer parent)
+        {
+            string[] prefixParts = pragmaName.Split(variableSplitter, 2);
+            // Check to make sure there are 2 parts and neither is an empty string.
+            if (2 != prefixParts.Length)
+            {
+                throw new WixException(WixErrors.InvalidPreprocessorPragma(sourceLineNumbers, pragmaName));
+            }
+            string prefix = prefixParts[0];
+            string pragma = prefixParts[1];
+
+            if (String.IsNullOrEmpty(prefix) || String.IsNullOrEmpty(pragma))
+            {
+                throw new WixException(WixErrors.InvalidPreprocessorPragma(sourceLineNumbers, pragmaName));
+            }
+
+            switch (prefix)
+            {
+                case "wix":
+                    switch (pragma)
+                    {
+                        // Add any core defined pragmas here
+                        default:
+                            this.OnMessage(WixWarnings.PreprocessorUnknownPragma(sourceLineNumbers, pragmaName));
+                            break;
+                    }
+                    break;
+                default:
+                    PreprocessorExtension extension = (PreprocessorExtension)this.extensionsByPrefix[prefix];
+                    if (null == extension || !extension.ProcessPragma(sourceLineNumbers, prefix, pragma, args, parent))
+                    {
+                        this.OnMessage(WixWarnings.PreprocessorUnknownPragma(sourceLineNumbers, pragmaName));
+                    }
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// Evaluate a function.
+        /// </summary>
+        /// <param name="sourceLineNumbers">The source line information for the function.</param>
+        /// <param name="function">The function expression including the prefix and name.</param>
+        /// <returns>The function value.</returns>
+        public string EvaluateFunction(SourceLineNumber sourceLineNumbers, string function)
+        {
+            string[] prefixParts = function.Split(variableSplitter, 2);
+            // Check to make sure there are 2 parts and neither is an empty string.
+            if (2 != prefixParts.Length || 0 >= prefixParts[0].Length || 0 >= prefixParts[1].Length)
+            {
+                throw new WixException(WixErrors.InvalidPreprocessorFunction(sourceLineNumbers, function));
+            }
+            string prefix = prefixParts[0];
+
+            string[] functionParts = prefixParts[1].Split(new char[] { '(' }, 2);
+            // Check to make sure there are 2 parts, neither is an empty string, and the second part ends with a closing paren.
+            if (2 != functionParts.Length || 0 >= functionParts[0].Length || 0 >= functionParts[1].Length || !functionParts[1].EndsWith(")", StringComparison.Ordinal))
+            {
+                throw new WixException(WixErrors.InvalidPreprocessorFunction(sourceLineNumbers, function));
+            }
+            string functionName = functionParts[0];
+
+            // Remove the trailing closing paren.
+            string allArgs = functionParts[1].Substring(0, functionParts[1].Length - 1);
+
+            // Parse the arguments and preprocess them.
+            string[] args = allArgs.Split(argumentSplitter);
+            for (int i = 0; i < args.Length; i++)
+            {
+                args[i] = this.PreprocessString(sourceLineNumbers, args[i].Trim());
+            }
+
+            string result = this.EvaluateFunction(sourceLineNumbers, prefix, functionName, args);
+
+            // If the function didn't evaluate, try to evaluate the original value as a variable to support 
+            // the use of open and closed parens inside variable names. Example: $(env.ProgramFiles(x86)) should resolve.
+            if (null == result)
+            {
+                result = this.GetVariableValue(sourceLineNumbers, function, false);
+            }
+
+            return result;
+        }
+
+        /// <summary>
+        /// Evaluate a function.
+        /// </summary>
+        /// <param name="sourceLineNumbers">The source line information for the function.</param>
+        /// <param name="prefix">The function prefix.</param>
+        /// <param name="function">The function name.</param>
+        /// <param name="args">The arguments for the function.</param>
+        /// <returns>The function value or null if the function is not defined.</returns>
+        public string EvaluateFunction(SourceLineNumber sourceLineNumbers, string prefix, string function, string[] args)
+        {
+            if (String.IsNullOrEmpty(prefix))
+            {
+                throw new ArgumentNullException("prefix");
+            }
+
+            if (String.IsNullOrEmpty(function))
+            {
+                throw new ArgumentNullException("function");
+            }
+
+            switch (prefix)
+            {
+                case "fun":
+                    switch (function)
+                    {
+                        case "AutoVersion":
+                            // Make sure the base version is specified
+                            if (args.Length == 0 || String.IsNullOrEmpty(args[0]))
+                            {
+                                throw new WixException(WixErrors.InvalidPreprocessorFunctionAutoVersion(sourceLineNumbers));
+                            }
+
+                            // Build = days since 1/1/2000; Revision = seconds since midnight / 2
+                            DateTime now = DateTime.UtcNow;
+                            TimeSpan build = now - new DateTime(2000, 1, 1);
+                            TimeSpan revision = now - new DateTime(now.Year, now.Month, now.Day);
+
+                            return String.Join(".", args[0], (int)build.TotalDays, (int)(revision.TotalSeconds / 2));
+
+                        default:
+                            return null;
+                    }
+                default:
+                    PreprocessorExtension extension = (PreprocessorExtension)this.extensionsByPrefix[prefix];
+                    if (null != extension)
+                    {
+                        try
+                        {
+                            return extension.EvaluateFunction(prefix, function, args);
+                        }
+                        catch (Exception e)
+                        {
+                            throw new WixException(WixErrors.PreprocessorExtensionEvaluateFunctionFailed(sourceLineNumbers, prefix, function, String.Join(",", args), e.Message));
+                        }
+                    }
+                    else
+                    {
+                        return null;
+                    }
+            }
+        }
+
+        /// <summary>
+        /// Get the value of a variable expression like var.name.
+        /// </summary>
+        /// <param name="sourceLineNumbers">The source line information for the variable.</param>
+        /// <param name="variable">The variable expression including the optional prefix and name.</param>
+        /// <param name="allowMissingPrefix">true to allow the variable prefix to be missing.</param>
+        /// <returns>The variable value.</returns>
+        public string GetVariableValue(SourceLineNumber sourceLineNumbers, string variable, bool allowMissingPrefix)
+        {
+            // Strip the "$(" off the front.
+            if (variable.StartsWith("$(", StringComparison.Ordinal))
+            {
+                variable = variable.Substring(2);
+            }
+
+            string[] parts = variable.Split(variableSplitter, 2);
+
+            if (1 == parts.Length) // missing prefix
+            {
+                if (allowMissingPrefix)
+                {
+                    return this.GetVariableValue(sourceLineNumbers, "var", parts[0]);
+                }
+                else
+                {
+                    throw new WixException(WixErrors.InvalidPreprocessorVariable(sourceLineNumbers, variable));
+                }
+            }
+            else
+            {
+                // check for empty variable name
+                if (0 < parts[1].Length)
+                {
+                    string result = this.GetVariableValue(sourceLineNumbers, parts[0], parts[1]);
+
+                    // If we didn't find it and we allow missing prefixes and the variable contains a dot, perhaps the dot isn't intended to indicate a prefix
+                    if (null == result && allowMissingPrefix && variable.Contains("."))
+                    {
+                        result = this.GetVariableValue(sourceLineNumbers, "var", variable);
+                    }
+
+                    return result;
+                }
+                else
+                {
+                    throw new WixException(WixErrors.InvalidPreprocessorVariable(sourceLineNumbers, variable));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Get the value of a variable.
+        /// </summary>
+        /// <param name="sourceLineNumbers">The source line information for the function.</param>
+        /// <param name="prefix">The variable prefix.</param>
+        /// <param name="name">The variable name.</param>
+        /// <returns>The variable value or null if the variable is not set.</returns>
+        public string GetVariableValue(SourceLineNumber sourceLineNumbers, string prefix, string name)
+        {
+            if (String.IsNullOrEmpty(prefix))
+            {
+                throw new ArgumentNullException("prefix");
+            }
+
+            if (String.IsNullOrEmpty(name))
+            {
+                throw new ArgumentNullException("name");
+            }
+
+            switch (prefix)
+            {
+                case "env":
+                    return Environment.GetEnvironmentVariable(name);
+                case "sys":
+                    switch (name)
+                    {
+                        case "CURRENTDIR":
+                            return String.Concat(Directory.GetCurrentDirectory(), Path.DirectorySeparatorChar);
+                        case "SOURCEFILEDIR":
+                            return String.Concat(Path.GetDirectoryName(sourceLineNumbers.FileName), Path.DirectorySeparatorChar);
+                        case "SOURCEFILEPATH":
+                            return sourceLineNumbers.FileName;
+                        case "PLATFORM":
+                            this.OnMessage(WixWarnings.DeprecatedPreProcVariable(sourceLineNumbers, "$(sys.PLATFORM)", "$(sys.BUILDARCH)"));
+
+                            goto case "BUILDARCH";
+
+                        case "BUILDARCH":
+                            switch (this.currentPlatform)
+                            {
+                                case Platform.X86:
+                                    return "x86";
+                                case Platform.X64:
+                                    return "x64";
+                                case Platform.IA64:
+                                    return "ia64";
+                                case Platform.ARM:
+                                    return "arm";
+                                default:
+                                    throw new ArgumentException(WixStrings.EXP_UnknownPlatformEnum, this.currentPlatform.ToString());
+                            }
+                        default:
+                            return null;
+                    }
+                case "var":
+                    string result = null;
+                    return this.variables.TryGetValue(name, out result) ? result : null;
+                default:
+                    PreprocessorExtension extension = (PreprocessorExtension)this.extensionsByPrefix[prefix];
+                    if (null != extension)
+                    {
+                        try
+                        {
+                            return extension.GetVariableValue(prefix, name);
+                        }
+                        catch (Exception e)
+                        {
+                            throw new WixException(WixErrors.PreprocessorExtensionGetVariableValueFailed(sourceLineNumbers, prefix, name, e.Message));
+                        }
+                    }
+                    else
+                    {
+                        return null;
+                    }
+            }
+        }
+
+        /// <summary>
+        /// Sends a message to the message delegate if there is one.
+        /// </summary>
+        /// <param name="mea">Message event arguments.</param>
+        public void OnMessage(MessageEventArgs e)
+        {
+            Messaging.Instance.OnMessage(e);
+        }
+
+        /// <summary>
+        /// Sends resolved variable to delegate if there is one.
+        /// </summary>
+        /// <param name="mea">Message event arguments.</param>
+        public void OnResolvedVariable(ResolvedVariableEventArgs mea)
+        {
+            if (null != this.ResolvedVariable)
+            {
+                this.ResolvedVariable(this, mea);
+            }
+        }
+
+        /// <summary>
+        /// Add a variable.
+        /// </summary>
+        /// <param name="sourceLineNumbers">The source line information of the variable.</param>
+        /// <param name="name">The variable name.</param>
+        /// <param name="value">The variable value.</param>
+        internal void AddVariable(SourceLineNumber sourceLineNumbers, string name, string value)
+        {
+            this.AddVariable(sourceLineNumbers, name, value, true);
+        }
+
+        /// <summary>
+        /// Add a variable.
+        /// </summary>
+        /// <param name="sourceLineNumbers">The source line information of the variable.</param>
+        /// <param name="name">The variable name.</param>
+        /// <param name="value">The variable value.</param>
+        /// <param name="overwrite">Set to true to show variable overwrite warning.</param>
+        internal void AddVariable(SourceLineNumber sourceLineNumbers, string name, string value, bool showWarning)
+        {
+            string currentValue = this.GetVariableValue(sourceLineNumbers, "var", name);
+
+            if (null == currentValue)
+            {
+                this.variables.Add(name, value);
+            }
+            else
+            {
+                if (showWarning)
+                {
+                    this.OnMessage(WixWarnings.VariableDeclarationCollision(sourceLineNumbers, name, value, currentValue));
+                }
+
+                this.variables[name] = value;
+            }
+        }
+
+        /// <summary>
+        /// Remove a variable.
+        /// </summary>
+        /// <param name="sourceLineNumbers">The source line information of the variable.</param>
+        /// <param name="name">The variable name.</param>
+        internal void RemoveVariable(SourceLineNumber sourceLineNumbers, string name)
+        {
+            if (!this.variables.Remove(name))
+            {
+                this.OnMessage(WixErrors.CannotReundefineVariable(sourceLineNumbers, name));
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/ProcessedStreamEventHandler.cs b/src/WixToolset.Core/ProcessedStreamEventHandler.cs
new file mode 100644
index 00000000..de6b5d1f
--- /dev/null
+++ b/src/WixToolset.Core/ProcessedStreamEventHandler.cs
@@ -0,0 +1,43 @@
+// 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
+{
+    using System;
+    using System.Xml.Linq;
+
+    /// <summary>
+    /// Preprocessed output stream event handler delegate.
+    /// </summary>
+    /// <param name="sender">Sender of the message.</param>
+    /// <param name="ea">Arguments for the preprocessed stream event.</param>
+    public delegate void ProcessedStreamEventHandler(object sender, ProcessedStreamEventArgs e);
+
+    /// <summary>
+    /// Event args for preprocessed stream event.
+    /// </summary>
+    public class ProcessedStreamEventArgs : EventArgs
+    {
+        /// <summary>
+        /// Creates a new ProcessedStreamEventArgs.
+        /// </summary>
+        /// <param name="sourceFile">Source file that is preprocessed.</param>
+        /// <param name="document">Preprocessed output document.</param>
+        public ProcessedStreamEventArgs(string sourceFile, XDocument document)
+        {
+            this.SourceFile = sourceFile;
+            this.Document = document;
+        }
+
+        /// <summary>
+        /// Gets the full path of the source file.
+        /// </summary>
+        /// <value>The full path of the source file.</value>
+        public string SourceFile { get; private set; }
+
+        /// <summary>
+        /// Gets the preprocessed output stream.
+        /// </summary>
+        /// <value>The the preprocessed output stream.</value>
+        public XDocument Document { get; private set; }
+    }
+}
diff --git a/src/WixToolset.Core/ProvidesDependency.cs b/src/WixToolset.Core/ProvidesDependency.cs
new file mode 100644
index 00000000..ea96b5c8
--- /dev/null
+++ b/src/WixToolset.Core/ProvidesDependency.cs
@@ -0,0 +1,108 @@
+// 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
+{
+    using System;
+    using System.Xml;
+    using WixToolset.Data;
+
+    /// <summary>
+    /// Represents an authored or imported dependency provider.
+    /// </summary>
+    internal sealed class ProvidesDependency
+    {
+        /// <summary>
+        /// Creates a new instance of the <see cref="ProviderDependency"/> class from a <see cref="Row"/>.
+        /// </summary>
+        /// <param name="row">The <see cref="Row"/> from which data is imported.</param>
+        internal ProvidesDependency(Row row)
+            : this((string)row[2], (string)row[3], (string)row[4], (int?)row[5])
+        {
+        }
+
+        /// <summary>
+        /// Creates a new instance of the <see cref="ProviderDependency"/> class.
+        /// </summary>
+        /// <param name="key">The unique key of the dependency.</param>
+        /// <param name="attributes">Additional attributes for the dependency.</param>
+        internal ProvidesDependency(string key, string version, string displayName, int? attributes)
+        {
+            this.Key = key;
+            this.Version = version;
+            this.DisplayName = displayName;
+            this.Attributes = attributes;
+        }
+
+        /// <summary>
+        /// Gets or sets the unique key of the package provider.
+        /// </summary>
+        internal string Key { get; set; }
+
+        /// <summary>
+        /// Gets or sets the version of the package provider.
+        /// </summary>
+        internal string Version { get; set; }
+
+        /// <summary>
+        /// Gets or sets the display name of the package provider.
+        /// </summary>
+        internal string DisplayName { get; set; }
+
+        /// <summary>
+        /// Gets or sets the attributes for the dependency.
+        /// </summary>
+        internal int? Attributes { get; set; }
+
+        /// <summary>
+        /// Gets or sets whether the dependency was imported from the package.
+        /// </summary>
+        internal bool Imported { get; set; }
+
+        /// <summary>
+        /// Gets whether certain properties are the same.
+        /// </summary>
+        /// <param name="other">Another <see cref="ProvidesDependency"/> to compare.</param>
+        /// <remarks>This is not the same as object equality, but only checks a subset of properties
+        /// to determine if the objects are similar and could be merged into a collection.</remarks>
+        /// <returns>True if certain properties are the same.</returns>
+        internal bool Equals(ProvidesDependency other)
+        {
+            if (null != other)
+            {
+                return this.Key == other.Key &&
+                       this.Version == other.Version &&
+                       this.DisplayName == other.DisplayName;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Writes the dependency to the bundle XML manifest.
+        /// </summary>
+        /// <param name="writer">The <see cref="XmlTextWriter"/> for the bundle XML manifest.</param>
+        internal void WriteXml(XmlTextWriter writer)
+        {
+            writer.WriteStartElement("Provides");
+            writer.WriteAttributeString("Key", this.Key);
+
+            if (!String.IsNullOrEmpty(this.Version))
+            {
+                writer.WriteAttributeString("Version", this.Version);
+            }
+
+            if (!String.IsNullOrEmpty(this.DisplayName))
+            {
+                writer.WriteAttributeString("DisplayName", this.DisplayName);
+            }
+
+            if (this.Imported)
+            {
+                // The package dependency was explicitly authored into the manifest.
+                writer.WriteAttributeString("Imported", "yes");
+            }
+
+            writer.WriteEndElement();
+        }
+    }
+}
diff --git a/src/WixToolset.Core/ProvidesDependencyCollection.cs b/src/WixToolset.Core/ProvidesDependencyCollection.cs
new file mode 100644
index 00000000..a777afb0
--- /dev/null
+++ b/src/WixToolset.Core/ProvidesDependencyCollection.cs
@@ -0,0 +1,64 @@
+// 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
+{
+    using System;
+    using System.Collections.ObjectModel;
+
+    /// <summary>
+    /// A case-insensitive collection of unique <see cref="ProvidesDependency"/> objects.
+    /// </summary>
+    internal sealed class ProvidesDependencyCollection : KeyedCollection<string, ProvidesDependency>
+    {
+        /// <summary>
+        /// Creates a case-insensitive collection of unique <see cref="ProvidesDependency"/> objects.
+        /// </summary>
+        internal ProvidesDependencyCollection()
+            : base(StringComparer.InvariantCultureIgnoreCase)
+        {
+        }
+
+        /// <summary>
+        /// Adds the <see cref="ProvidesDependency"/> to the collection if it doesn't already exist.
+        /// </summary>
+        /// <param name="dependency">The <see cref="ProvidesDependency"/> to add to the collection.</param>
+        /// <returns>True if the <see cref="ProvidesDependency"/> was added to the collection; otherwise, false.</returns>
+        /// <exception cref="ArgumentNullException">The <paramref name="dependency"/> parameter is null.</exception>
+        internal bool Merge(ProvidesDependency dependency)
+        {
+            if (null == dependency)
+            {
+                throw new ArgumentNullException("dependency");
+            }
+
+            // If the dependency key is already in the collection, verify equality for a subset of properties.
+            if (this.Contains(dependency.Key))
+            {
+                ProvidesDependency current = this[dependency.Key];
+                if (!current.Equals(dependency))
+                {
+                    return false;
+                }
+            }
+
+            base.Add(dependency);
+            return true;
+        }
+
+        /// <summary>
+        /// Gets the <see cref="ProvidesDependency.Key"/> for the <paramref name="dependency"/>.
+        /// </summary>
+        /// <param name="dependency">The dependency to index.</param>
+        /// <exception cref="ArgumentNullException">The <paramref name="dependency"/> parameter is null.</exception>
+        /// <returns>The <see cref="ProvidesDependency.Key"/> for the <paramref name="dependency"/>.</returns>
+        protected override string GetKeyForItem(ProvidesDependency dependency)
+        {
+            if (null == dependency)
+            {
+                throw new ArgumentNullException("dependency");
+            }
+
+            return dependency.Key;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/ResolvedVariableEventHandler.cs b/src/WixToolset.Core/ResolvedVariableEventHandler.cs
new file mode 100644
index 00000000..232ad9e4
--- /dev/null
+++ b/src/WixToolset.Core/ResolvedVariableEventHandler.cs
@@ -0,0 +1,39 @@
+// 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
+{
+    using System;
+    using System.Text;
+    using WixToolset.Data;
+
+    public delegate void ResolvedVariableEventHandler(object sender, ResolvedVariableEventArgs e);
+
+    public class ResolvedVariableEventArgs : EventArgs
+    {
+        private SourceLineNumber sourceLineNumbers;
+        private string variableName;
+        private string variableValue;
+
+        public ResolvedVariableEventArgs(SourceLineNumber sourceLineNumbers, string variableName, string variableValue)
+        {
+            this.sourceLineNumbers = sourceLineNumbers;
+            this.variableName = variableName;
+            this.variableValue = variableValue;
+        }
+
+        public SourceLineNumber SourceLineNumbers
+        {
+            get { return this.sourceLineNumbers; }
+        }
+
+        public string VariableName
+        {
+            get { return this.variableName; }
+        }
+
+        public string VariableValue
+        {
+            get { return this.variableValue; }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/SourceFile.cs b/src/WixToolset.Core/SourceFile.cs
new file mode 100644
index 00000000..3b1e386a
--- /dev/null
+++ b/src/WixToolset.Core/SourceFile.cs
@@ -0,0 +1,21 @@
+// 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.Core
+{
+    using System.IO;
+
+    internal class SourceFile
+    {
+        public SourceFile(string sourcePath, string outputPath)
+        {
+            this.SourcePath = sourcePath;
+            this.OutputPath = outputPath;
+        }
+
+        public string OutputPath { get; set; }
+
+        public string SourcePath { get; set; }
+
+        public Stream Stream { get; set; }
+    }
+}
diff --git a/src/WixToolset.Core/Unbinder.cs b/src/WixToolset.Core/Unbinder.cs
new file mode 100644
index 00000000..744d5536
--- /dev/null
+++ b/src/WixToolset.Core/Unbinder.cs
@@ -0,0 +1,1491 @@
+// 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
+{
+    using System;
+    using System.CodeDom.Compiler;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Collections.Specialized;
+    using System.ComponentModel;
+    using System.Globalization;
+    using System.IO;
+    using System.Linq;
+    using System.Text.RegularExpressions;
+    using WixToolset.Bind;
+    using WixToolset.Bind.Bundles;
+    using WixToolset.Cab;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+    using WixToolset.Extensibility;
+    using WixToolset.Msi;
+    using WixToolset.Core.Native;
+    using WixToolset.Ole32;
+
+    /// <summary>
+    /// Unbinder core of the WiX toolset.
+    /// </summary>
+    public sealed class Unbinder : IMessageHandler
+    {
+        private string emptyFile;
+        private bool isAdminImage;
+        private int sectionCount;
+        private bool suppressDemodularization;
+        private bool suppressExtractCabinets;
+        private TableDefinitionCollection tableDefinitions;
+        private ArrayList unbinderExtensions;
+        // private TempFileCollection tempFiles;
+
+        /// <summary>
+        /// Creates a new unbinder object with a default set of table definitions.
+        /// </summary>
+        public Unbinder()
+        {
+            this.tableDefinitions = new TableDefinitionCollection(WindowsInstallerStandard.GetTableDefinitions());
+            this.unbinderExtensions = new ArrayList();
+        }
+
+        /// <summary>
+        /// Gets or sets whether the input msi is an admin image.
+        /// </summary>
+        /// <value>Set to true if the input msi is part of an admin image.</value>
+        public bool IsAdminImage
+        {
+            get { return this.isAdminImage; }
+            set { this.isAdminImage = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the option to suppress demodularizing values.
+        /// </summary>
+        /// <value>The option to suppress demodularizing values.</value>
+        public bool SuppressDemodularization
+        {
+            get { return this.suppressDemodularization; }
+            set { this.suppressDemodularization = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the option to suppress extracting cabinets.
+        /// </summary>
+        /// <value>The option to suppress extracting cabinets.</value>
+        public bool SuppressExtractCabinets
+        {
+            get { return this.suppressExtractCabinets; }
+            set { this.suppressExtractCabinets = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the temporary path for the Binder.  If left null, the binder
+        /// will use %TEMP% environment variable.
+        /// </summary>
+        /// <value>Path to temp files.</value>
+        public string TempFilesLocation
+        {
+            get
+            {
+                // return null == this.tempFiles ? String.Empty : this.tempFiles.BasePath;
+                return Path.GetTempPath();
+            }
+
+            // set
+            // {
+            //     if (null == value)
+            //     {
+            //         this.tempFiles = new TempFileCollection();
+            //     }
+            //     else
+            //     {
+            //         this.tempFiles = new TempFileCollection(value);
+            //     }
+            // }
+        }
+
+        /// <summary>
+        /// Adds extension data.
+        /// </summary>
+        /// <param name="data">The extension data to add.</param>
+        public void AddExtensionData(IExtensionData data)
+        {
+            if (null != data.TableDefinitions)
+            {
+                foreach (TableDefinition tableDefinition in data.TableDefinitions)
+                {
+                    if (!this.tableDefinitions.Contains(tableDefinition.Name))
+                    {
+                        this.tableDefinitions.Add(tableDefinition);
+                    }
+                    else
+                    {
+                        Messaging.Instance.OnMessage(WixErrors.DuplicateExtensionTable(data.GetType().ToString(), tableDefinition.Name));
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Adds an extension.
+        /// </summary>
+        /// <param name="extension">The extension to add.</param>
+        public void AddExtension(IUnbinderExtension extension)
+        {
+            this.unbinderExtensions.Add(extension);
+        }
+
+        /// <summary>
+        /// Unbind a Windows Installer file.
+        /// </summary>
+        /// <param name="file">The Windows Installer file.</param>
+        /// <param name="outputType">The type of output to create.</param>
+        /// <param name="exportBasePath">The path where files should be exported.</param>
+        /// <returns>The output representing the database.</returns>
+        public Output Unbind(string file, OutputType outputType, string exportBasePath)
+        {
+            if (!File.Exists(file))
+            {
+                if (OutputType.Transform == outputType)
+                {
+                    throw new WixException(WixErrors.FileNotFound(null, file, "Transform"));
+                }
+                else
+                {
+                    throw new WixException(WixErrors.FileNotFound(null, file, "Database"));
+                }
+            }
+
+            // if we don't have the temporary files object yet, get one
+            Directory.CreateDirectory(this.TempFilesLocation); // ensure the base path is there
+
+            if (OutputType.Patch == outputType)
+            {
+                return this.UnbindPatch(file, exportBasePath);
+            }
+            else if (OutputType.Transform == outputType)
+            {
+                return this.UnbindTransform(file, exportBasePath);
+            }
+            else if (OutputType.Bundle == outputType)
+            {
+                return this.UnbindBundle(file, exportBasePath);
+            }
+            else // other database types
+            {
+                return this.UnbindDatabase(file, outputType, exportBasePath);
+            }
+        }
+
+        /// <summary>
+        /// Cleans up the temp files used by the Decompiler.
+        /// </summary>
+        /// <returns>True if all files were deleted, false otherwise.</returns>
+        /// <remarks>
+        /// This should be called after every call to Decompile to ensure there
+        /// are no conflicts between each decompiled database.
+        /// </remarks>
+        public bool DeleteTempFiles()
+        {
+#if REDO_IN_NETCORE
+            bool deleted = Common.DeleteTempFiles(this.tempFiles.BasePath, this);
+
+            if (deleted)
+            {
+                this.tempFiles = null; // temp files have been deleted, no need to remember this now
+            }
+
+            return deleted;
+#endif
+            return true;
+        }
+
+        /// <summary>
+        /// Sends a message to the message delegate if there is one.
+        /// </summary>
+        /// <param name="mea">Message event arguments.</param>
+        public void OnMessage(MessageEventArgs e)
+        {
+            Messaging.Instance.OnMessage(e);
+        }
+
+        /// <summary>
+        /// Unbind an MSI database file.
+        /// </summary>
+        /// <param name="databaseFile">The database file.</param>
+        /// <param name="outputType">The output type.</param>
+        /// <param name="exportBasePath">The path where files should be exported.</param>
+        /// <returns>The unbound database.</returns>
+        private Output UnbindDatabase(string databaseFile, OutputType outputType, string exportBasePath)
+        {
+            Output output;
+
+            try
+            {
+                using (Database database = new Database(databaseFile, OpenDatabase.ReadOnly))
+                {
+                    output = this.UnbindDatabase(databaseFile, database, outputType, exportBasePath, false);
+
+                    // extract the files from the cabinets
+                    if (null != exportBasePath && !this.suppressExtractCabinets)
+                    {
+                        this.ExtractCabinets(output, database, databaseFile, exportBasePath);
+                    }
+                }
+            }
+            catch (Win32Exception e)
+            {
+                if (0x6E == e.NativeErrorCode) // ERROR_OPEN_FAILED
+                {
+                    throw new WixException(WixErrors.OpenDatabaseFailed(databaseFile));
+                }
+
+                throw;
+            }
+
+            return output;
+        }
+
+        /// <summary>
+        /// Unbind an MSI database file.
+        /// </summary>
+        /// <param name="databaseFile">The database file.</param>
+        /// <param name="database">The opened database.</param>
+        /// <param name="outputType">The type of output to create.</param>
+        /// <param name="exportBasePath">The path where files should be exported.</param>
+        /// <param name="skipSummaryInfo">Option to skip unbinding the _SummaryInformation table.</param>
+        /// <returns>The output representing the database.</returns>
+        private Output UnbindDatabase(string databaseFile, Database database, OutputType outputType, string exportBasePath, bool skipSummaryInfo)
+        {
+            string modularizationGuid = null;
+            Output output = new Output(new SourceLineNumber(databaseFile));
+            View validationView = null;
+
+            // set the output type
+            output.Type = outputType;
+
+            // get the codepage
+            database.Export("_ForceCodepage", this.TempFilesLocation, "_ForceCodepage.idt");
+            using (StreamReader sr = File.OpenText(Path.Combine(this.TempFilesLocation, "_ForceCodepage.idt")))
+            {
+                string line;
+
+                while (null != (line = sr.ReadLine()))
+                {
+                    string[] data = line.Split('\t');
+
+                    if (2 == data.Length)
+                    {
+                        output.Codepage = Convert.ToInt32(data[0], CultureInfo.InvariantCulture);
+                    }
+                }
+            }
+
+            // get the summary information table if it exists; it won't if unbinding a transform
+            if (!skipSummaryInfo)
+            {
+                using (SummaryInformation summaryInformation = new SummaryInformation(database))
+                {
+                    Table table = new Table(null, this.tableDefinitions["_SummaryInformation"]);
+
+                    for (int i = 1; 19 >= i; i++)
+                    {
+                        string value = summaryInformation.GetProperty(i);
+
+                        if (0 < value.Length)
+                        {
+                            Row row = table.CreateRow(output.SourceLineNumbers);
+                            row[0] = i;
+                            row[1] = value;
+                        }
+                    }
+
+                    output.Tables.Add(table);
+                }
+            }
+
+            try
+            {
+                // open a view on the validation table if it exists
+                if (database.TableExists("_Validation"))
+                {
+                    validationView = database.OpenView("SELECT * FROM `_Validation` WHERE `Table` = ? AND `Column` = ?");
+                }
+
+                // get the normal tables
+                using (View tablesView = database.OpenExecuteView("SELECT * FROM _Tables"))
+                {
+                    while (true)
+                    {
+                        using (Record tableRecord = tablesView.Fetch())
+                        {
+                            if (null == tableRecord)
+                            {
+                                break;
+                            }
+
+                            string tableName = tableRecord.GetString(1);
+
+                            using (View tableView = database.OpenExecuteView(String.Format(CultureInfo.InvariantCulture, "SELECT * FROM `{0}`", tableName)))
+                            {
+                                List<ColumnDefinition> columns;
+                                using (Record columnNameRecord = tableView.GetColumnInfo(MsiInterop.MSICOLINFONAMES),
+                                              columnTypeRecord = tableView.GetColumnInfo(MsiInterop.MSICOLINFOTYPES))
+                                {
+                                    // index the primary keys
+                                    HashSet<string> tablePrimaryKeys = new HashSet<string>();
+                                    using (Record primaryKeysRecord = database.PrimaryKeys(tableName))
+                                    {
+                                        int primaryKeysFieldCount = primaryKeysRecord.GetFieldCount();
+
+                                        for (int i = 1; i <= primaryKeysFieldCount; i++)
+                                        {
+                                            tablePrimaryKeys.Add(primaryKeysRecord.GetString(i));
+                                        }
+                                    }
+
+                                    int columnCount = columnNameRecord.GetFieldCount();
+                                    columns = new List<ColumnDefinition>(columnCount);
+                                    for (int i = 1; i <= columnCount; i++)
+                                    {
+                                        string columnName = columnNameRecord.GetString(i);
+                                        string idtType = columnTypeRecord.GetString(i);
+
+                                        ColumnType columnType;
+                                        int length;
+                                        bool nullable;
+
+                                        ColumnCategory columnCategory = ColumnCategory.Unknown;
+                                        ColumnModularizeType columnModularizeType = ColumnModularizeType.None;
+                                        bool primary = tablePrimaryKeys.Contains(columnName);
+                                        bool minValueSet = false;
+                                        int minValue = -1;
+                                        bool maxValueSet = false;
+                                        int maxValue = -1;
+                                        string keyTable = null;
+                                        bool keyColumnSet = false;
+                                        int keyColumn = -1;
+                                        string category = null;
+                                        string set = null;
+                                        string description = null;
+
+                                        // get the column type, length, and whether its nullable
+                                        switch (Char.ToLower(idtType[0], CultureInfo.InvariantCulture))
+                                        {
+                                            case 'i':
+                                                columnType = ColumnType.Number;
+                                                break;
+                                            case 'l':
+                                                columnType = ColumnType.Localized;
+                                                break;
+                                            case 's':
+                                                columnType = ColumnType.String;
+                                                break;
+                                            case 'v':
+                                                columnType = ColumnType.Object;
+                                                break;
+                                            default:
+                                                // TODO: error
+                                                columnType = ColumnType.Unknown;
+                                                break;
+                                        }
+                                        length = Convert.ToInt32(idtType.Substring(1), CultureInfo.InvariantCulture);
+                                        nullable = Char.IsUpper(idtType[0]);
+
+                                        // try to get validation information
+                                        if (null != validationView)
+                                        {
+                                            using (Record validationRecord = new Record(2))
+                                            {
+                                                validationRecord.SetString(1, tableName);
+                                                validationRecord.SetString(2, columnName);
+
+                                                validationView.Execute(validationRecord);
+                                            }
+
+                                            using (Record validationRecord = validationView.Fetch())
+                                            {
+                                                if (null != validationRecord)
+                                                {
+                                                    string validationNullable = validationRecord.GetString(3);
+                                                    minValueSet = !validationRecord.IsNull(4);
+                                                    minValue = (minValueSet ? validationRecord.GetInteger(4) : -1);
+                                                    maxValueSet = !validationRecord.IsNull(5);
+                                                    maxValue = (maxValueSet ? validationRecord.GetInteger(5) : -1);
+                                                    keyTable = (!validationRecord.IsNull(6) ? validationRecord.GetString(6) : null);
+                                                    keyColumnSet = !validationRecord.IsNull(7);
+                                                    keyColumn = (keyColumnSet ? validationRecord.GetInteger(7) : -1);
+                                                    category = (!validationRecord.IsNull(8) ? validationRecord.GetString(8) : null);
+                                                    set = (!validationRecord.IsNull(9) ? validationRecord.GetString(9) : null);
+                                                    description = (!validationRecord.IsNull(10) ? validationRecord.GetString(10) : null);
+
+                                                    // check the validation nullable value against the column definition
+                                                    if (null == validationNullable)
+                                                    {
+                                                        // TODO: warn for illegal validation nullable column
+                                                    }
+                                                    else if ((nullable && "Y" != validationNullable) || (!nullable && "N" != validationNullable))
+                                                    {
+                                                        // TODO: warn for mismatch between column definition and validation nullable
+                                                    }
+
+                                                    // convert category to ColumnCategory
+                                                    if (null != category)
+                                                    {
+                                                        try
+                                                        {
+                                                            columnCategory = (ColumnCategory)Enum.Parse(typeof(ColumnCategory), category, true);
+                                                        }
+                                                        catch (ArgumentException)
+                                                        {
+                                                            columnCategory = ColumnCategory.Unknown;
+                                                        }
+                                                    }
+                                                }
+                                                else
+                                                {
+                                                    // TODO: warn about no validation information
+                                                }
+                                            }
+                                        }
+
+                                        // guess the modularization type
+                                        if ("Icon" == keyTable && 1 == keyColumn)
+                                        {
+                                            columnModularizeType = ColumnModularizeType.Icon;
+                                        }
+                                        else if ("Condition" == columnName)
+                                        {
+                                            columnModularizeType = ColumnModularizeType.Condition;
+                                        }
+                                        else if (ColumnCategory.Formatted == columnCategory || ColumnCategory.FormattedSDDLText == columnCategory)
+                                        {
+                                            columnModularizeType = ColumnModularizeType.Property;
+                                        }
+                                        else if (ColumnCategory.Identifier == columnCategory)
+                                        {
+                                            columnModularizeType = ColumnModularizeType.Column;
+                                        }
+
+                                        columns.Add(new ColumnDefinition(columnName, columnType, length, primary, nullable, columnModularizeType, (ColumnType.Localized == columnType), minValueSet, minValue, maxValueSet, maxValue, keyTable, keyColumnSet, keyColumn, columnCategory, set, description, true, true));
+                                    }
+                                }
+
+                                TableDefinition tableDefinition = new TableDefinition(tableName, columns, false, false);
+
+                                // use our table definitions if core properties are the same; this allows us to take advantage
+                                // of wix concepts like localizable columns which current code assumes
+                                if (this.tableDefinitions.Contains(tableName) && 0 == tableDefinition.CompareTo(this.tableDefinitions[tableName]))
+                                {
+                                    tableDefinition = this.tableDefinitions[tableName];
+                                }
+
+                                Table table = new Table(null, tableDefinition);
+
+                                while (true)
+                                {
+                                    using (Record rowRecord = tableView.Fetch())
+                                    {
+                                        if (null == rowRecord)
+                                        {
+                                            break;
+                                        }
+
+                                        int recordCount = rowRecord.GetFieldCount();
+                                        Row row = table.CreateRow(output.SourceLineNumbers);
+
+                                        for (int i = 0; recordCount > i && row.Fields.Length > i; i++)
+                                        {
+                                            if (rowRecord.IsNull(i + 1))
+                                            {
+                                                if (!row.Fields[i].Column.Nullable)
+                                                {
+                                                    // TODO: display an error for a null value in a non-nullable field OR
+                                                    // display a warning and put an empty string in the value to let the compiler handle it
+                                                    // (the second option is risky because the later code may make certain assumptions about
+                                                    // the contents of a row value)
+                                                }
+                                            }
+                                            else
+                                            {
+                                                switch (row.Fields[i].Column.Type)
+                                                {
+                                                    case ColumnType.Number:
+                                                        bool success = false;
+                                                        int intValue = rowRecord.GetInteger(i + 1);
+                                                        if (row.Fields[i].Column.IsLocalizable)
+                                                        {
+                                                            success = row.BestEffortSetField(i, Convert.ToString(intValue, CultureInfo.InvariantCulture));
+                                                        }
+                                                        else
+                                                        {
+                                                            success = row.BestEffortSetField(i, intValue);
+                                                        }
+
+                                                        if (!success)
+                                                        {
+                                                            this.OnMessage(WixWarnings.BadColumnDataIgnored(row.SourceLineNumbers, Convert.ToString(intValue, CultureInfo.InvariantCulture), tableName, row.Fields[i].Column.Name));
+                                                        }
+                                                        break;
+                                                    case ColumnType.Object:
+                                                        string sourceFile = "FILE NOT EXPORTED, USE THE dark.exe -x OPTION TO EXPORT BINARIES";
+
+                                                        if (null != exportBasePath)
+                                                        {
+                                                            string relativeSourceFile = Path.Combine(tableName, row.GetPrimaryKey('.'));
+                                                            sourceFile = Path.Combine(exportBasePath, relativeSourceFile);
+
+                                                            // ensure the parent directory exists
+                                                            System.IO.Directory.CreateDirectory(Path.Combine(exportBasePath, tableName));
+
+                                                            using (FileStream fs = System.IO.File.Create(sourceFile))
+                                                            {
+                                                                int bytesRead;
+                                                                byte[] buffer = new byte[512];
+
+                                                                while (0 != (bytesRead = rowRecord.GetStream(i + 1, buffer, buffer.Length)))
+                                                                {
+                                                                    fs.Write(buffer, 0, bytesRead);
+                                                                }
+                                                            }
+                                                        }
+
+                                                        row[i] = sourceFile;
+                                                        break;
+                                                    default:
+                                                        string value = rowRecord.GetString(i + 1);
+
+                                                        switch (row.Fields[i].Column.Category)
+                                                        {
+                                                            case ColumnCategory.Guid:
+                                                                value = value.ToUpper(CultureInfo.InvariantCulture);
+                                                                break;
+                                                        }
+
+                                                        // de-modularize
+                                                        if (!this.suppressDemodularization && OutputType.Module == output.Type && ColumnModularizeType.None != row.Fields[i].Column.ModularizeType)
+                                                        {
+                                                            Regex modularization = new Regex(@"\.[0-9A-Fa-f]{8}_[0-9A-Fa-f]{4}_[0-9A-Fa-f]{4}_[0-9A-Fa-f]{4}_[0-9A-Fa-f]{12}");
+
+                                                            if (null == modularizationGuid)
+                                                            {
+                                                                Match match = modularization.Match(value);
+                                                                if (match.Success)
+                                                                {
+                                                                    modularizationGuid = String.Concat('{', match.Value.Substring(1).Replace('_', '-'), '}');
+                                                                }
+                                                            }
+
+                                                            value = modularization.Replace(value, String.Empty);
+                                                        }
+
+                                                        // escape "$(" for the preprocessor
+                                                        value = value.Replace("$(", "$$(");
+
+                                                        // escape things that look like wix variables
+                                                        MatchCollection matches = Common.WixVariableRegex.Matches(value);
+                                                        for (int j = matches.Count - 1; 0 <= j; j--)
+                                                        {
+                                                            value = value.Insert(matches[j].Index, "!");
+                                                        }
+
+                                                        row[i] = value;
+                                                        break;
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+
+                                output.Tables.Add(table);
+                            }
+
+                        }
+                    }
+                }
+            }
+            finally
+            {
+                if (null != validationView)
+                {
+                    validationView.Close();
+                }
+            }
+
+            // set the modularization guid as the PackageCode
+            if (null != modularizationGuid)
+            {
+                Table table = output.Tables["_SummaryInformation"];
+
+                foreach (Row row in table.Rows)
+                {
+                    if (9 == (int)row[0]) // PID_REVNUMBER
+                    {
+                        row[1] = modularizationGuid;
+                    }
+                }
+            }
+
+            if (this.isAdminImage)
+            {
+                GenerateWixFileTable(databaseFile, output);
+                GenerateSectionIds(output);
+            }
+
+            return output;
+        }
+
+        /// <summary>
+        /// Creates section ids on rows which form logical groupings of resources.
+        /// </summary>
+        /// <param name="output">The Output that represents the msi database.</param>
+        private void GenerateSectionIds(Output output)
+        {
+            // First assign and index section ids for the tables that are in their own sections.
+            AssignSectionIdsToTable(output.Tables["Binary"], 0);
+            Hashtable componentSectionIdIndex = AssignSectionIdsToTable(output.Tables["Component"], 0);
+            Hashtable customActionSectionIdIndex = AssignSectionIdsToTable(output.Tables["CustomAction"], 0);
+            AssignSectionIdsToTable(output.Tables["Directory"], 0);
+            Hashtable featureSectionIdIndex = AssignSectionIdsToTable(output.Tables["Feature"], 0);
+            AssignSectionIdsToTable(output.Tables["Icon"], 0);
+            Hashtable digitalCertificateSectionIdIndex = AssignSectionIdsToTable(output.Tables["MsiDigitalCertificate"], 0);
+            AssignSectionIdsToTable(output.Tables["Property"], 0);
+
+            // Now handle all the tables that rely on the first set of indexes but also produce their own indexes. Order matters here.
+            Hashtable fileSectionIdIndex = ConnectTableToSectionAndIndex(output.Tables["File"], componentSectionIdIndex, 1, 0);
+            Hashtable appIdSectionIdIndex = ConnectTableToSectionAndIndex(output.Tables["Class"], componentSectionIdIndex, 2, 5);
+            Hashtable odbcDataSourceSectionIdIndex = ConnectTableToSectionAndIndex(output.Tables["ODBCDataSource"], componentSectionIdIndex, 1, 0);
+            Hashtable odbcDriverSectionIdIndex = ConnectTableToSectionAndIndex(output.Tables["ODBCDriver"], componentSectionIdIndex, 1, 0);
+            Hashtable registrySectionIdIndex = ConnectTableToSectionAndIndex(output.Tables["Registry"], componentSectionIdIndex, 5, 0);
+            Hashtable serviceInstallSectionIdIndex = ConnectTableToSectionAndIndex(output.Tables["ServiceInstall"], componentSectionIdIndex, 11, 0);
+
+            // Now handle all the tables which only rely on previous indexes and order does not matter.
+            foreach (Table table in output.Tables)
+            {
+                switch (table.Name)
+                {
+                    case "WixFile":
+                    case "MsiFileHash":
+                        ConnectTableToSection(table, fileSectionIdIndex, 0);
+                        break;
+                    case "MsiAssembly":
+                    case "MsiAssemblyName":
+                        ConnectTableToSection(table, componentSectionIdIndex, 0);
+                        break;
+                    case "MsiPackageCertificate":
+                    case "MsiPatchCertificate":
+                        ConnectTableToSection(table, digitalCertificateSectionIdIndex, 1);
+                        break;
+                    case "CreateFolder":
+                    case "FeatureComponents":
+                    case "MoveFile":
+                    case "ReserveCost":
+                    case "ODBCTranslator":
+                        ConnectTableToSection(table, componentSectionIdIndex, 1);
+                        break;
+                    case "TypeLib":
+                        ConnectTableToSection(table, componentSectionIdIndex, 2);
+                        break;
+                    case "Shortcut":
+                    case "Environment":
+                        ConnectTableToSection(table, componentSectionIdIndex, 3);
+                        break;
+                    case "RemoveRegistry":
+                        ConnectTableToSection(table, componentSectionIdIndex, 4);
+                        break;
+                    case "ServiceControl":
+                        ConnectTableToSection(table, componentSectionIdIndex, 5);
+                        break;
+                    case "IniFile":
+                    case "RemoveIniFile":
+                        ConnectTableToSection(table, componentSectionIdIndex, 7);
+                        break;
+                    case "AppId":
+                        ConnectTableToSection(table, appIdSectionIdIndex, 0);
+                        break;
+                    case "Condition":
+                        ConnectTableToSection(table, featureSectionIdIndex, 0);
+                        break;
+                    case "ODBCSourceAttribute":
+                        ConnectTableToSection(table, odbcDataSourceSectionIdIndex, 0);
+                        break;
+                    case "ODBCAttribute":
+                        ConnectTableToSection(table, odbcDriverSectionIdIndex, 0);
+                        break;
+                    case "AdminExecuteSequence":
+                    case "AdminUISequence":
+                    case "AdvtExecuteSequence":
+                    case "AdvtUISequence":
+                    case "InstallExecuteSequence":
+                    case "InstallUISequence":
+                        ConnectTableToSection(table, customActionSectionIdIndex, 0);
+                        break;
+                    case "LockPermissions":
+                    case "MsiLockPermissions":
+                        foreach (Row row in table.Rows)
+                        {
+                            string lockObject = (string)row[0];
+                            string tableName = (string)row[1];
+                            switch (tableName)
+                            {
+                                case "File":
+                                    row.SectionId = (string)fileSectionIdIndex[lockObject];
+                                    break;
+                                case "Registry":
+                                    row.SectionId = (string)registrySectionIdIndex[lockObject];
+                                    break;
+                                case "ServiceInstall":
+                                    row.SectionId = (string)serviceInstallSectionIdIndex[lockObject];
+                                    break;
+                            }
+                        }
+                        break;
+                }
+            }
+
+            // Now pass the output to each unbinder extension to allow them to analyze the output and determine thier proper section ids.
+            foreach (IUnbinderExtension extension in this.unbinderExtensions)
+            {
+                extension.GenerateSectionIds(output);
+            }
+        }
+
+        /// <summary>
+        /// Creates new section ids on all the rows in a table.
+        /// </summary>
+        /// <param name="table">The table to add sections to.</param>
+        /// <param name="rowPrimaryKeyIndex">The index of the column which is used by other tables to reference this table.</param>
+        /// <returns>A Hashtable containing the tables key for each row paired with its assigned section id.</returns>
+        private Hashtable AssignSectionIdsToTable(Table table, int rowPrimaryKeyIndex)
+        {
+            Hashtable hashtable = new Hashtable();
+            if (null != table)
+            {
+                foreach (Row row in table.Rows)
+                {
+                    row.SectionId = GetNewSectionId();
+                    hashtable.Add(row[rowPrimaryKeyIndex], row.SectionId);
+                }
+            }
+            return hashtable;
+        }
+
+        /// <summary>
+        /// Connects a table's rows to an already sectioned table.
+        /// </summary>
+        /// <param name="table">The table containing rows that need to be connected to sections.</param>
+        /// <param name="sectionIdIndex">A hashtable containing keys to map table to its section.</param>
+        /// <param name="rowIndex">The index of the column which is used as the foreign key in to the sectionIdIndex.</param>
+        private static void ConnectTableToSection(Table table, Hashtable sectionIdIndex, int rowIndex)
+        {
+            if (null != table)
+            {
+                foreach (Row row in table.Rows)
+                {
+                    if (sectionIdIndex.ContainsKey(row[rowIndex]))
+                    {
+                        row.SectionId = (string)sectionIdIndex[row[rowIndex]];
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Connects a table's rows to an already sectioned table and produces an index for other tables to connect to it.
+        /// </summary>
+        /// <param name="table">The table containing rows that need to be connected to sections.</param>
+        /// <param name="sectionIdIndex">A hashtable containing keys to map table to its section.</param>
+        /// <param name="rowIndex">The index of the column which is used as the foreign key in to the sectionIdIndex.</param>
+        /// <param name="rowPrimaryKeyIndex">The index of the column which is used by other tables to reference this table.</param>
+        /// <returns>A Hashtable containing the tables key for each row paired with its assigned section id.</returns>
+        private static Hashtable ConnectTableToSectionAndIndex(Table table, Hashtable sectionIdIndex, int rowIndex, int rowPrimaryKeyIndex)
+        {
+            Hashtable newHashTable = new Hashtable();
+            if (null != table)
+            {
+                foreach (Row row in table.Rows)
+                {
+                    if (!sectionIdIndex.ContainsKey(row[rowIndex]))
+                    {
+                        continue;
+                    }
+
+                    row.SectionId = (string)sectionIdIndex[row[rowIndex]];
+                    if (null != row[rowPrimaryKeyIndex])
+                    {
+                        newHashTable.Add(row[rowPrimaryKeyIndex], row.SectionId);
+                    }
+                }
+            }
+            return newHashTable;
+        }
+
+        /// <summary>
+        /// Creates a new section identifier to be used when adding a section to an output.
+        /// </summary>
+        /// <returns>A string representing a new section id.</returns>
+        private string GetNewSectionId()
+        {
+            this.sectionCount++;
+            return "wix.section." + this.sectionCount.ToString(CultureInfo.InvariantCulture);
+        }
+
+        /// <summary>
+        /// Generates the WixFile table based on a path to an admin image msi and an Output.
+        /// </summary>
+        /// <param name="databaseFile">The path to the msi database file in an admin image.</param>
+        /// <param name="output">The Output that represents the msi database.</param>
+        private void GenerateWixFileTable(string databaseFile, Output output)
+        {
+            string adminRootPath = Path.GetDirectoryName(databaseFile);
+
+            Hashtable componentDirectoryIndex = new Hashtable();
+            Table componentTable = output.Tables["Component"];
+            foreach (Row row in componentTable.Rows)
+            {
+                componentDirectoryIndex.Add(row[0], row[2]);
+            }
+
+            // Index full source paths for all directories
+            Hashtable directoryDirectoryParentIndex = new Hashtable();
+            Hashtable directoryFullPathIndex = new Hashtable();
+            Hashtable directorySourceNameIndex = new Hashtable();
+            Table directoryTable = output.Tables["Directory"];
+            foreach (Row row in directoryTable.Rows)
+            {
+                directoryDirectoryParentIndex.Add(row[0], row[1]);
+                if (null == row[1])
+                {
+                    directoryFullPathIndex.Add(row[0], adminRootPath);
+                }
+                else
+                {
+                    directorySourceNameIndex.Add(row[0], GetAdminSourceName((string)row[2]));
+                }
+            }
+
+            foreach (DictionaryEntry directoryEntry in directoryDirectoryParentIndex)
+            {
+                if (!directoryFullPathIndex.ContainsKey(directoryEntry.Key))
+                {
+                    GetAdminFullPath((string)directoryEntry.Key, directoryDirectoryParentIndex, directorySourceNameIndex, directoryFullPathIndex);
+                }
+            }
+
+            Table fileTable = output.Tables["File"];
+            Table wixFileTable = output.EnsureTable(this.tableDefinitions["WixFile"]);
+            foreach (Row row in fileTable.Rows)
+            {
+                WixFileRow wixFileRow = new WixFileRow(null, this.tableDefinitions["WixFile"]);
+                wixFileRow.File = (string)row[0];
+                wixFileRow.Directory = (string)componentDirectoryIndex[(string)row[1]];
+                wixFileRow.Source = Path.Combine((string)directoryFullPathIndex[wixFileRow.Directory], GetAdminSourceName((string)row[2]));
+
+                if (!File.Exists(wixFileRow.Source))
+                {
+                    throw new WixException(WixErrors.WixFileNotFound(wixFileRow.Source));
+                }
+
+                wixFileTable.Rows.Add(wixFileRow);
+            }
+        }
+
+        /// <summary>
+        /// Gets the full path of a directory. Populates the full path index with the directory's full path and all of its parent directorie's full paths.
+        /// </summary>
+        /// <param name="directory">The directory identifier.</param>
+        /// <param name="directoryDirectoryParentIndex">The Hashtable containing all the directory to directory parent mapping.</param>
+        /// <param name="directorySourceNameIndex">The Hashtable containing all the directory to source name mapping.</param>
+        /// <param name="directoryFullPathIndex">The Hashtable containing a mapping between all of the directories and their previously calculated full paths.</param>
+        /// <returns>The full path to the directory.</returns>
+        private string GetAdminFullPath(string directory, Hashtable directoryDirectoryParentIndex, Hashtable directorySourceNameIndex, Hashtable directoryFullPathIndex)
+        {
+            string parent = (string)directoryDirectoryParentIndex[directory];
+            string sourceName = (string)directorySourceNameIndex[directory];
+
+            string parentFullPath;
+            if (directoryFullPathIndex.ContainsKey(parent))
+            {
+                parentFullPath = (string)directoryFullPathIndex[parent];
+            }
+            else
+            {
+                parentFullPath = GetAdminFullPath(parent, directoryDirectoryParentIndex, directorySourceNameIndex, directoryFullPathIndex);
+            }
+
+            if (null == sourceName)
+            {
+                sourceName = String.Empty;
+            }
+
+            string fullPath = Path.Combine(parentFullPath, sourceName);
+            directoryFullPathIndex.Add(directory, fullPath);
+
+            return fullPath;
+        }
+
+        /// <summary>
+        /// Get the source name in an admin image.
+        /// </summary>
+        /// <param name="value">The Filename value.</param>
+        /// <returns>The source name of the directory in an admin image.</returns>
+        private static string GetAdminSourceName(string value)
+        {
+            string name = null;
+            string[] names;
+            string shortname = null;
+            string shortsourcename = null;
+            string sourcename = null;
+
+            names = Installer.GetNames(value);
+
+            if (null != names[0] && "." != names[0])
+            {
+                if (null != names[1])
+                {
+                    shortname = names[0];
+                }
+                else
+                {
+                    name = names[0];
+                }
+            }
+
+            if (null != names[1])
+            {
+                name = names[1];
+            }
+
+            if (null != names[2])
+            {
+                if (null != names[3])
+                {
+                    shortsourcename = names[2];
+                }
+                else
+                {
+                    sourcename = names[2];
+                }
+            }
+
+            if (null != names[3])
+            {
+                sourcename = names[3];
+            }
+
+            if (null != sourcename)
+            {
+                return sourcename;
+            }
+            else if (null != shortsourcename)
+            {
+                return shortsourcename;
+            }
+            else if (null != name)
+            {
+                return name;
+            }
+            else
+            {
+                return shortname;
+            }
+        }
+
+        /// <summary>
+        /// Unbind an MSP patch file.
+        /// </summary>
+        /// <param name="patchFile">The patch file.</param>
+        /// <param name="exportBasePath">The path where files should be exported.</param>
+        /// <returns>The unbound patch.</returns>
+        private Output UnbindPatch(string patchFile, string exportBasePath)
+        {
+            Output patch;
+
+            // patch files are essentially database files (use a special flag to let the API know its a patch file)
+            try
+            {
+                using (Database database = new Database(patchFile, OpenDatabase.ReadOnly | OpenDatabase.OpenPatchFile))
+                {
+                    patch = this.UnbindDatabase(patchFile, database, OutputType.Patch, exportBasePath, false);
+                }
+            }
+            catch (Win32Exception e)
+            {
+                if (0x6E == e.NativeErrorCode) // ERROR_OPEN_FAILED
+                {
+                    throw new WixException(WixErrors.OpenDatabaseFailed(patchFile));
+                }
+
+                throw;
+            }
+
+            // retrieve the transforms (they are in substorages)
+            using (Storage storage = Storage.Open(patchFile, StorageMode.Read | StorageMode.ShareDenyWrite))
+            {
+                Table summaryInformationTable = patch.Tables["_SummaryInformation"];
+                foreach (Row row in summaryInformationTable.Rows)
+                {
+                    if (8 == (int)row[0]) // PID_LASTAUTHOR
+                    {
+                        string value = (string)row[1];
+
+                        foreach (string decoratedSubStorageName in value.Split(';'))
+                        {
+                            string subStorageName = decoratedSubStorageName.Substring(1);
+                            string transformFile = Path.Combine(this.TempFilesLocation, String.Concat("Transform", Path.DirectorySeparatorChar, subStorageName, ".mst"));
+
+                            // ensure the parent directory exists
+                            System.IO.Directory.CreateDirectory(Path.GetDirectoryName(transformFile));
+
+                            // copy the substorage to a new storage for the transform file
+                            using (Storage subStorage = storage.OpenStorage(subStorageName))
+                            {
+                                using (Storage transformStorage = Storage.CreateDocFile(transformFile, StorageMode.ReadWrite | StorageMode.ShareExclusive | StorageMode.Create))
+                                {
+                                    subStorage.CopyTo(transformStorage);
+                                }
+                            }
+
+                            // unbind the transform
+                            Output transform = this.UnbindTransform(transformFile, (null == exportBasePath ? null : Path.Combine(exportBasePath, subStorageName)));
+                            patch.SubStorages.Add(new SubStorage(subStorageName, transform));
+                        }
+
+                        break;
+                    }
+                }
+            }
+
+            // extract the files from the cabinets
+            // TODO: use per-transform export paths for support of multi-product patches
+            if (null != exportBasePath && !this.suppressExtractCabinets)
+            {
+                using (Database database = new Database(patchFile, OpenDatabase.ReadOnly | OpenDatabase.OpenPatchFile))
+                {
+                    foreach (SubStorage subStorage in patch.SubStorages)
+                    {
+                        // only patch transforms should carry files
+                        if (subStorage.Name.StartsWith("#", StringComparison.Ordinal))
+                        {
+                            this.ExtractCabinets(subStorage.Data, database, patchFile, exportBasePath);
+                        }
+                    }
+                }
+            }
+
+            return patch;
+        }
+
+        /// <summary>
+        /// Unbind an MSI transform file.
+        /// </summary>
+        /// <param name="transformFile">The transform file.</param>
+        /// <param name="exportBasePath">The path where files should be exported.</param>
+        /// <returns>The unbound transform.</returns>
+        private Output UnbindTransform(string transformFile, string exportBasePath)
+        {
+            Output transform = new Output(new SourceLineNumber(transformFile));
+            transform.Type = OutputType.Transform;
+
+            // get the summary information table
+            using (SummaryInformation summaryInformation = new SummaryInformation(transformFile))
+            {
+                Table table = transform.EnsureTable(this.tableDefinitions["_SummaryInformation"]);
+
+                for (int i = 1; 19 >= i; i++)
+                {
+                    string value = summaryInformation.GetProperty(i);
+
+                    if (0 < value.Length)
+                    {
+                        Row row = table.CreateRow(transform.SourceLineNumbers);
+                        row[0] = i;
+                        row[1] = value;
+                    }
+                }
+            }
+
+            // create a schema msi which hopefully matches the table schemas in the transform
+            Output schemaOutput = new Output(null);
+            string msiDatabaseFile = Path.Combine(this.TempFilesLocation, "schema.msi");
+            foreach (TableDefinition tableDefinition in this.tableDefinitions)
+            {
+                // skip unreal tables and the Patch table
+                if (!tableDefinition.Unreal && "Patch" != tableDefinition.Name)
+                {
+                    schemaOutput.EnsureTable(tableDefinition);
+                }
+            }
+
+            Hashtable addedRows = new Hashtable();
+            Table transformViewTable;
+
+            // Bind the schema msi.
+            this.GenerateDatabase(schemaOutput, msiDatabaseFile);
+
+            // apply the transform to the database and retrieve the modifications
+            using (Database msiDatabase = new Database(msiDatabaseFile, OpenDatabase.Transact))
+            {
+                // apply the transform with the ViewTransform option to collect all the modifications
+                msiDatabase.ApplyTransform(transformFile, TransformErrorConditions.All | TransformErrorConditions.ViewTransform);
+
+                // unbind the database
+                Output transformViewOutput = this.UnbindDatabase(msiDatabaseFile, msiDatabase, OutputType.Product, exportBasePath, true);
+
+                // index the added and possibly modified rows (added rows may also appears as modified rows)
+                transformViewTable = transformViewOutput.Tables["_TransformView"];
+                Hashtable modifiedRows = new Hashtable();
+                foreach (Row row in transformViewTable.Rows)
+                {
+                    string tableName = (string)row[0];
+                    string columnName = (string)row[1];
+                    string primaryKeys = (string)row[2];
+
+                    if ("INSERT" == columnName)
+                    {
+                        string index = String.Concat(tableName, ':', primaryKeys);
+
+                        addedRows.Add(index, null);
+                    }
+                    else if ("CREATE" != columnName && "DELETE" != columnName && "DROP" != columnName && null != primaryKeys) // modified row
+                    {
+                        string index = String.Concat(tableName, ':', primaryKeys);
+
+                        modifiedRows[index] = row;
+                    }
+                }
+
+                // create placeholder rows for modified rows to make the transform insert the updated values when its applied
+                foreach (Row row in modifiedRows.Values)
+                {
+                    string tableName = (string)row[0];
+                    string columnName = (string)row[1];
+                    string primaryKeys = (string)row[2];
+
+                    string index = String.Concat(tableName, ':', primaryKeys);
+
+                    // ignore information for added rows
+                    if (!addedRows.Contains(index))
+                    {
+                        Table table = schemaOutput.Tables[tableName];
+                        this.CreateRow(table, primaryKeys, true);
+                    }
+                }
+            }
+
+            // Re-bind the schema output with the placeholder rows.
+            this.GenerateDatabase(schemaOutput, msiDatabaseFile);
+
+            // apply the transform to the database and retrieve the modifications
+            using (Database msiDatabase = new Database(msiDatabaseFile, OpenDatabase.Transact))
+            {
+                try
+                {
+                    // apply the transform
+                    msiDatabase.ApplyTransform(transformFile, TransformErrorConditions.All);
+
+                    // commit the database to guard against weird errors with streams
+                    msiDatabase.Commit();
+                }
+                catch (Win32Exception ex)
+                {
+                    if (0x65B == ex.NativeErrorCode)
+                    {
+                        // this commonly happens when the transform was built
+                        // against a database schema different from the internal
+                        // table definitions
+                        throw new WixException(WixErrors.TransformSchemaMismatch());
+                    }
+                }
+
+                // unbind the database
+                Output output = this.UnbindDatabase(msiDatabaseFile, msiDatabase, OutputType.Product, exportBasePath, true);
+
+                // index all the rows to easily find modified rows
+                Hashtable rows = new Hashtable();
+                foreach (Table table in output.Tables)
+                {
+                    foreach (Row row in table.Rows)
+                    {
+                        rows.Add(String.Concat(table.Name, ':', row.GetPrimaryKey('\t', " ")), row);
+                    }
+                }
+
+                // process the _TransformView rows into transform rows
+                foreach (Row row in transformViewTable.Rows)
+                {
+                    string tableName = (string)row[0];
+                    string columnName = (string)row[1];
+                    string primaryKeys = (string)row[2];
+
+                    Table table = transform.EnsureTable(this.tableDefinitions[tableName]);
+
+                    if ("CREATE" == columnName) // added table
+                    {
+                        table.Operation = TableOperation.Add;
+                    }
+                    else if ("DELETE" == columnName) // deleted row
+                    {
+                        Row deletedRow = this.CreateRow(table, primaryKeys, false);
+                        deletedRow.Operation = RowOperation.Delete;
+                    }
+                    else if ("DROP" == columnName) // dropped table
+                    {
+                        table.Operation = TableOperation.Drop;
+                    }
+                    else if ("INSERT" == columnName) // added row
+                    {
+                        string index = String.Concat(tableName, ':', primaryKeys);
+                        Row addedRow = (Row)rows[index];
+                        addedRow.Operation = RowOperation.Add;
+                        table.Rows.Add(addedRow);
+                    }
+                    else if (null != primaryKeys) // modified row
+                    {
+                        string index = String.Concat(tableName, ':', primaryKeys);
+
+                        // the _TransformView table includes information for added rows
+                        // that looks like modified rows so it sometimes needs to be ignored
+                        if (!addedRows.Contains(index))
+                        {
+                            Row modifiedRow = (Row)rows[index];
+
+                            // mark the field as modified
+                            int indexOfModifiedValue = -1;
+                            for (int i = 0; i < modifiedRow.TableDefinition.Columns.Count; ++i)
+                            {
+                                if (columnName.Equals(modifiedRow.TableDefinition.Columns[i].Name, StringComparison.Ordinal))
+                                {
+                                    indexOfModifiedValue = i;
+                                    break;
+                                }
+                            }
+                            modifiedRow.Fields[indexOfModifiedValue].Modified = true;
+
+                            // move the modified row into the transform the first time its encountered
+                            if (RowOperation.None == modifiedRow.Operation)
+                            {
+                                modifiedRow.Operation = RowOperation.Modify;
+                                table.Rows.Add(modifiedRow);
+                            }
+                        }
+                    }
+                    else // added column
+                    {
+                        ColumnDefinition column = table.Definition.Columns.Single(c => c.Name.Equals(columnName, StringComparison.Ordinal));
+                        column.Added = true;
+                    }
+                }
+            }
+
+            return transform;
+        }
+
+        private void GenerateDatabase(Output output, string databaseFile)
+        {
+            GenerateDatabaseCommand command = new GenerateDatabaseCommand();
+            command.Extensions = Enumerable.Empty<IBinderExtension>();
+            command.FileManagers = Enumerable.Empty<IBinderFileManager>();
+            command.Output = output;
+            command.OutputPath = databaseFile;
+            command.KeepAddedColumns = true;
+            command.UseSubDirectory = false;
+            command.SuppressAddingValidationRows = true;
+            command.TableDefinitions = this.tableDefinitions;
+            command.TempFilesLocation = this.TempFilesLocation;
+            command.Codepage = -1;
+            command.Execute();
+        }
+
+        /// <summary>
+        /// Unbind a bundle.
+        /// </summary>
+        /// <param name="bundleFile">The bundle file.</param>
+        /// <param name="exportBasePath">The path where files should be exported.</param>
+        /// <returns>The unbound bundle.</returns>
+        private Output UnbindBundle(string bundleFile, string exportBasePath)
+        {
+            string uxExtractPath = Path.Combine(exportBasePath, "UX");
+            string acExtractPath = Path.Combine(exportBasePath, "AttachedContainer");
+
+            using (BurnReader reader = BurnReader.Open(bundleFile))
+            {
+                reader.ExtractUXContainer(uxExtractPath, this.TempFilesLocation);
+                reader.ExtractAttachedContainer(acExtractPath, this.TempFilesLocation);
+            }
+
+            return null;
+        }
+
+        /// <summary>
+        /// Create a deleted or modified row.
+        /// </summary>
+        /// <param name="table">The table containing the row.</param>
+        /// <param name="primaryKeys">The primary keys of the row.</param>
+        /// <param name="setRequiredFields">Option to set all required fields with placeholder values.</param>
+        /// <returns>The new row.</returns>
+        private Row CreateRow(Table table, string primaryKeys, bool setRequiredFields)
+        {
+            Row row = table.CreateRow(null);
+
+            string[] primaryKeyParts = primaryKeys.Split('\t');
+            int primaryKeyPartIndex = 0;
+
+            for (int i = 0; i < table.Definition.Columns.Count; i++)
+            {
+                ColumnDefinition columnDefinition = table.Definition.Columns[i];
+
+                if (columnDefinition.PrimaryKey)
+                {
+                    if (ColumnType.Number == columnDefinition.Type && !columnDefinition.IsLocalizable)
+                    {
+                        row[i] = Convert.ToInt32(primaryKeyParts[primaryKeyPartIndex++], CultureInfo.InvariantCulture);
+                    }
+                    else
+                    {
+                        row[i] = primaryKeyParts[primaryKeyPartIndex++];
+                    }
+                }
+                else if (setRequiredFields)
+                {
+                    if (ColumnType.Number == columnDefinition.Type && !columnDefinition.IsLocalizable)
+                    {
+                        row[i] = 1;
+                    }
+                    else if (ColumnType.Object == columnDefinition.Type)
+                    {
+                        if (null == this.emptyFile)
+                        {
+                            this.emptyFile = Path.GetTempFileName() + ".empty";
+                            using (FileStream fileStream = File.Create(this.emptyFile))
+                            {
+                            }
+                        }
+
+                        row[i] = this.emptyFile;
+                    }
+                    else
+                    {
+                        row[i] = "1";
+                    }
+                }
+            }
+
+            return row;
+        }
+
+        /// <summary>
+        /// Extract the cabinets from a database.
+        /// </summary>
+        /// <param name="output">The output to use when finding cabinets.</param>
+        /// <param name="database">The database containing the cabinets.</param>
+        /// <param name="databaseFile">The location of the database file.</param>
+        /// <param name="exportBasePath">The path where the files should be exported.</param>
+        private void ExtractCabinets(Output output, Database database, string databaseFile, string exportBasePath)
+        {
+            string databaseBasePath = Path.GetDirectoryName(databaseFile);
+            StringCollection cabinetFiles = new StringCollection();
+            SortedList embeddedCabinets = new SortedList();
+
+            // index all of the cabinet files
+            if (OutputType.Module == output.Type)
+            {
+                embeddedCabinets.Add(0, "MergeModule.CABinet");
+            }
+            else if (null != output.Tables["Media"])
+            {
+                foreach (MediaRow mediaRow in output.Tables["Media"].Rows)
+                {
+                    if (null != mediaRow.Cabinet)
+                    {
+                        if (OutputType.Product == output.Type ||
+                            (OutputType.Transform == output.Type && RowOperation.Add == mediaRow.Operation))
+                        {
+                            if (mediaRow.Cabinet.StartsWith("#", StringComparison.Ordinal))
+                            {
+                                embeddedCabinets.Add(mediaRow.DiskId, mediaRow.Cabinet.Substring(1));
+                            }
+                            else
+                            {
+                                cabinetFiles.Add(Path.Combine(databaseBasePath, mediaRow.Cabinet));
+                            }
+                        }
+                    }
+                }
+            }
+
+            // extract the embedded cabinet files from the database
+            if (0 < embeddedCabinets.Count)
+            {
+                using (View streamsView = database.OpenView("SELECT `Data` FROM `_Streams` WHERE `Name` = ?"))
+                {
+                    foreach (int diskId in embeddedCabinets.Keys)
+                    {
+                        using (Record record = new Record(1))
+                        {
+                            record.SetString(1, (string)embeddedCabinets[diskId]);
+                            streamsView.Execute(record);
+                        }
+
+                        using (Record record = streamsView.Fetch())
+                        {
+                            if (null != record)
+                            {
+                                // since the cabinets are stored in case-sensitive streams inside the msi, but the file system is not case-sensitive,
+                                // embedded cabinets must be extracted to a canonical file name (like their diskid) to ensure extraction will always work
+                                string cabinetFile = Path.Combine(this.TempFilesLocation, String.Concat("Media", Path.DirectorySeparatorChar, diskId.ToString(CultureInfo.InvariantCulture), ".cab"));
+
+                                // ensure the parent directory exists
+                                System.IO.Directory.CreateDirectory(Path.GetDirectoryName(cabinetFile));
+
+                                using (FileStream fs = System.IO.File.Create(cabinetFile))
+                                {
+                                    int bytesRead;
+                                    byte[] buffer = new byte[512];
+
+                                    while (0 != (bytesRead = record.GetStream(1, buffer, buffer.Length)))
+                                    {
+                                        fs.Write(buffer, 0, bytesRead);
+                                    }
+                                }
+
+                                cabinetFiles.Add(cabinetFile);
+                            }
+                            else
+                            {
+                                // TODO: warning about missing embedded cabinet
+                            }
+                        }
+                    }
+                }
+            }
+
+            // extract the cabinet files
+            if (0 < cabinetFiles.Count)
+            {
+                string fileDirectory = Path.Combine(exportBasePath, "File");
+
+                // delete the directory and its files to prevent cab extraction due to an existing file
+                if (Directory.Exists(fileDirectory))
+                {
+                    Directory.Delete(fileDirectory, true);
+                }
+
+                // ensure the directory exists or extraction will fail
+                Directory.CreateDirectory(fileDirectory);
+
+                foreach (string cabinetFile in cabinetFiles)
+                {
+                    using (WixExtractCab extractCab = new WixExtractCab())
+                    {
+                        try
+                        {
+                            extractCab.Extract(cabinetFile, fileDirectory);
+                        }
+                        catch (FileNotFoundException)
+                        {
+                            throw new WixException(WixErrors.FileNotFound(new SourceLineNumber(databaseFile), cabinetFile));
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Util.cs b/src/WixToolset.Core/Util.cs
new file mode 100644
index 00000000..5950fe0a
--- /dev/null
+++ b/src/WixToolset.Core/Util.cs
@@ -0,0 +1,17 @@
+// 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
+{
+    using System;
+
+    /// <summary>
+    /// Common Wix utility methods and types.
+    /// </summary>
+    public sealed class Util
+    {
+        /// <summary>
+        /// Set by WixToolTasks to indicate WIX is running inside MSBuild
+        /// </summary>
+        public static bool RunningInMsBuild { get; set; }
+    }
+}
diff --git a/src/WixToolset.Core/Uuid.cs b/src/WixToolset.Core/Uuid.cs
new file mode 100644
index 00000000..2e599793
--- /dev/null
+++ b/src/WixToolset.Core/Uuid.cs
@@ -0,0 +1,89 @@
+// 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
+{
+    using System;
+    using System.Net;
+    using System.Security.Cryptography;
+    using System.Text;
+
+    /// <summary>
+    /// Implementation of RFC 4122 - A Universally Unique Identifier (UUID) URN Namespace.
+    /// </summary>
+    internal sealed class Uuid
+    {
+        /// <summary>
+        /// Protect the constructor.
+        /// </summary>
+        private Uuid()
+        {
+        }
+
+        /// <summary>
+        /// Creates a version 3 name-based UUID.
+        /// </summary>
+        /// <param name="namespaceGuid">The namespace UUID.</param>
+        /// <param name="value">The value.</param>
+        /// <param name="backwardsCompatible">Flag to say to use MD5 instead of better SHA1.</param>
+        /// <returns>The UUID for the given namespace and value.</returns>
+        public static Guid NewUuid(Guid namespaceGuid, string value)
+        {
+            byte[] namespaceBytes = namespaceGuid.ToByteArray();
+            short uuidVersion = (short)0x5000;
+
+            // get the fields of the guid which are in host byte ordering
+            int timeLow = BitConverter.ToInt32(namespaceBytes, 0);
+            short timeMid = BitConverter.ToInt16(namespaceBytes, 4);
+            short timeHiAndVersion = BitConverter.ToInt16(namespaceBytes, 6);
+
+            // convert to network byte ordering
+            timeLow = IPAddress.HostToNetworkOrder(timeLow);
+            timeMid = IPAddress.HostToNetworkOrder(timeMid);
+            timeHiAndVersion = IPAddress.HostToNetworkOrder(timeHiAndVersion);
+
+            // get the bytes from the value
+            byte[] valueBytes = Encoding.Unicode.GetBytes(value);
+
+            // fill-in the hash input buffer
+            byte[] buffer = new byte[namespaceBytes.Length + valueBytes.Length];
+            Buffer.BlockCopy(BitConverter.GetBytes(timeLow), 0, buffer, 0, 4);
+            Buffer.BlockCopy(BitConverter.GetBytes(timeMid), 0, buffer, 4, 2);
+            Buffer.BlockCopy(BitConverter.GetBytes(timeHiAndVersion), 0, buffer, 6, 2);
+            Buffer.BlockCopy(namespaceBytes, 8, buffer, 8, 8);
+            Buffer.BlockCopy(valueBytes, 0, buffer, 16, valueBytes.Length);
+
+            // perform the appropriate hash of the namespace and value
+            byte[] hash;
+            using (SHA1 sha1 = SHA1.Create())
+            {
+                hash = sha1.ComputeHash(buffer);
+            }
+
+            // get the fields of the hash which are in network byte ordering
+            timeLow = BitConverter.ToInt32(hash, 0);
+            timeMid = BitConverter.ToInt16(hash, 4);
+            timeHiAndVersion = BitConverter.ToInt16(hash, 6);
+
+            // convert to network byte ordering
+            timeLow = IPAddress.NetworkToHostOrder(timeLow);
+            timeMid = IPAddress.NetworkToHostOrder(timeMid);
+            timeHiAndVersion = IPAddress.NetworkToHostOrder(timeHiAndVersion);
+
+            // set the version and variant bits
+            timeHiAndVersion &= 0x0FFF;
+            timeHiAndVersion += uuidVersion;
+            hash[8] &= 0x3F;
+            hash[8] |= 0x80;
+
+            // put back the converted values into a 128-bit value
+            byte[] guidBits = new byte[16];
+            Buffer.BlockCopy(hash, 0, guidBits, 0, 16);
+
+            Buffer.BlockCopy(BitConverter.GetBytes(timeLow), 0, guidBits, 0, 4);
+            Buffer.BlockCopy(BitConverter.GetBytes(timeMid), 0, guidBits, 4, 2);
+            Buffer.BlockCopy(BitConverter.GetBytes(timeHiAndVersion), 0, guidBits, 6, 2);
+
+            return new Guid(guidBits);
+        }
+    }
+}
diff --git a/src/WixToolset.Core/Validator.cs b/src/WixToolset.Core/Validator.cs
new file mode 100644
index 00000000..6420b9b7
--- /dev/null
+++ b/src/WixToolset.Core/Validator.cs
@@ -0,0 +1,401 @@
+// 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
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Collections.Specialized;
+    using System.ComponentModel;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Globalization;
+    using System.IO;
+    using System.Threading;
+    using WixToolset.Data;
+    using WixToolset.Extensibility;
+    using WixToolset.Msi;
+    using WixToolset.Core.Native;
+
+    /// <summary>
+    /// Runs internal consistency evaluators (ICEs) from cub files against a database.
+    /// </summary>
+    public sealed class Validator : IMessageHandler
+    {
+        private string actionName;
+        private StringCollection cubeFiles;
+        private ValidatorExtension extension;
+        private string[] ices;
+        private Output output;
+        private string[] suppressedICEs;
+        private InstallUIHandler validationUIHandler;
+        private bool validationSessionComplete;
+
+        /// <summary>
+        /// Instantiate a new Validator.
+        /// </summary>
+        public Validator()
+        {
+            this.cubeFiles = new StringCollection();
+            this.extension = new ValidatorExtension();
+            this.validationUIHandler = new InstallUIHandler(this.ValidationUIHandler);
+        }
+
+        /// <summary>
+        /// Gets or sets a <see cref="ValidatorExtension"/> that directs messages from the validator.
+        /// </summary>
+        /// <value>A <see cref="ValidatorExtension"/> that directs messages from the validator.</value>
+        public ValidatorExtension Extension
+        {
+            get { return this.extension; }
+            set { this.extension = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the list of ICEs to run.
+        /// </summary>
+        /// <value>The list of ICEs.</value>
+        [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays")]
+        public string[] ICEs
+        {
+            get { return this.ices; }
+            set { this.ices = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the output used for finding source line information.
+        /// </summary>
+        /// <value>The output used for finding source line information.</value>
+        public Output Output
+        {
+            // cache Output object until validation for changes in extension
+            get { return this.output; }
+            set { this.output = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets the suppressed ICEs.
+        /// </summary>
+        /// <value>The suppressed ICEs.</value>
+        [SuppressMessage("Microsoft.Performance", "CA1819:PropertiesShouldNotReturnArrays")]
+        public string[] SuppressedICEs
+        {
+            get { return this.suppressedICEs; }
+            set { this.suppressedICEs = value; }
+        }
+
+        /// <summary>
+        /// Sets the temporary path for the Binder.
+        /// </summary>
+        public string TempFilesLocation { private get; set; }
+
+        /// <summary>
+        /// Add a cube file to the validation run.
+        /// </summary>
+        /// <param name="cubeFile">A cube file.</param>
+        public void AddCubeFile(string cubeFile)
+        {
+            this.cubeFiles.Add(cubeFile);
+        }
+
+        /// <summary>
+        /// Validate a database.
+        /// </summary>
+        /// <param name="databaseFile">The database to validate.</param>
+        /// <returns>true if validation succeeded; false otherwise.</returns>
+        public void Validate(string databaseFile)
+        {
+            Dictionary<string, string> indexedICEs = new Dictionary<string, string>();
+            Dictionary<string, string> indexedSuppressedICEs = new Dictionary<string, string>();
+            int previousUILevel = (int)InstallUILevels.Basic;
+            IntPtr previousHwnd = IntPtr.Zero;
+            InstallUIHandler previousUIHandler = null;
+
+            if (null == databaseFile)
+            {
+                throw new ArgumentNullException("databaseFile");
+            }
+
+            // initialize the validator extension
+            this.extension.DatabaseFile = databaseFile;
+            this.extension.Output = this.output;
+            this.extension.InitializeValidator();
+
+            // Ensure the temporary files can be created.
+            Directory.CreateDirectory(this.TempFilesLocation);
+
+            // index the ICEs
+            if (null != this.ices)
+            {
+                foreach (string ice in this.ices)
+                {
+                    indexedICEs[ice] = null;
+                }
+            }
+
+            // index the suppressed ICEs
+            if (null != this.suppressedICEs)
+            {
+                foreach (string suppressedICE in this.suppressedICEs)
+                {
+                    indexedSuppressedICEs[suppressedICE] = null;
+                }
+            }
+
+            // copy the database to a temporary location so it can be manipulated
+            string tempDatabaseFile = Path.Combine(this.TempFilesLocation, Path.GetFileName(databaseFile));
+            File.Copy(databaseFile, tempDatabaseFile);
+
+            // remove the read-only property from the temporary database
+            FileAttributes attributes = File.GetAttributes(tempDatabaseFile);
+            File.SetAttributes(tempDatabaseFile, attributes & ~FileAttributes.ReadOnly);
+
+            Mutex mutex = new Mutex(false, "WixValidator");
+            try
+            {
+                if (!mutex.WaitOne(0, false))
+                {
+                    this.OnMessage(WixVerboses.ValidationSerialized());
+                    mutex.WaitOne();
+                }
+
+                using (Database database = new Database(tempDatabaseFile, OpenDatabase.Direct))
+                {
+                    bool propertyTableExists = database.TableExists("Property");
+                    string productCode = null;
+
+                    // remove the product code from the database before opening a session to prevent opening an installed product
+                    if (propertyTableExists)
+                    {
+                        using (View view = database.OpenExecuteView("SELECT `Value` FROM `Property` WHERE Property = 'ProductCode'"))
+                        {
+                            using (Record record = view.Fetch())
+                            {
+                                if (null != record)
+                                {
+                                    productCode = record.GetString(1);
+
+                                    using (View dropProductCodeView = database.OpenExecuteView("DELETE FROM `Property` WHERE `Property` = 'ProductCode'"))
+                                    {
+                                    }
+                                }
+                            }
+                        }
+                    }
+
+                    // merge in the cube databases
+                    foreach (string cubeFile in this.cubeFiles)
+                    {
+                        try
+                        {
+                            using (Database cubeDatabase = new Database(cubeFile, OpenDatabase.ReadOnly))
+                            {
+                                try
+                                {
+                                    database.Merge(cubeDatabase, "MergeConflicts");
+                                }
+                                catch
+                                {
+                                    // ignore merge errors since they are expected in the _Validation table
+                                }
+                            }
+                        }
+                        catch (Win32Exception e)
+                        {
+                            if (0x6E == e.NativeErrorCode) // ERROR_OPEN_FAILED
+                            {
+                                throw new WixException(WixErrors.CubeFileNotFound(cubeFile));
+                            }
+
+                            throw;
+                        }
+                    }
+
+                    // commit the database before proceeding to ensure the streams don't get confused
+                    database.Commit();
+
+                    // the property table may have been added to the database
+                    // from a cub database without the proper validation rows
+                    if (!propertyTableExists)
+                    {
+                        using (View view = database.OpenExecuteView("DROP table `Property`"))
+                        {
+                        }
+                    }
+
+                    // get all the action names for ICEs which have not been suppressed
+                    List<string> actions = new List<string>();
+                    using (View view = database.OpenExecuteView("SELECT `Action` FROM `_ICESequence` ORDER BY `Sequence`"))
+                    {
+                        while (true)
+                        {
+                            using (Record record = view.Fetch())
+                            {
+                                if (null == record)
+                                {
+                                    break;
+                                }
+
+                                string action = record.GetString(1);
+
+                                if (!indexedSuppressedICEs.ContainsKey(action))
+                                {
+                                    actions.Add(action);
+                                }
+                            }
+                        }
+                    }
+
+                    if (0 != indexedICEs.Count)
+                    {
+                        // Walk backwards and remove those that arent in the list
+                        for (int i = actions.Count - 1; 0 <= i; i--)
+                        {
+                            if (!indexedICEs.ContainsKey(actions[i]))
+                            {
+                                actions.RemoveAt(i);
+                            }
+                        }
+                    }
+
+                    // disable the internal UI handler and set an external UI handler
+                    previousUILevel = Installer.SetInternalUI((int)InstallUILevels.None, ref previousHwnd);
+                    previousUIHandler = Installer.SetExternalUI(this.validationUIHandler, (int)InstallLogModes.Error | (int)InstallLogModes.Warning | (int)InstallLogModes.User, IntPtr.Zero);
+
+                    // create a session for running the ICEs
+                    this.validationSessionComplete = false;
+                    using (Session session = new Session(database))
+                    {
+                        // add the product code back into the database
+                        if (null != productCode)
+                        {
+                            // some CUBs erroneously have a ProductCode property, so delete it if we just picked one up
+                            using (View dropProductCodeView = database.OpenExecuteView("DELETE FROM `Property` WHERE `Property` = 'ProductCode'"))
+                            {
+                            }
+
+                            using (View view = database.OpenExecuteView(String.Format(CultureInfo.InvariantCulture, "INSERT INTO `Property` (`Property`, `Value`) VALUES ('ProductCode', '{0}')", productCode)))
+                            {
+                            }
+                        }
+
+                        foreach (string action in actions)
+                        {
+                            this.actionName = action;
+                            try
+                            {
+                                session.DoAction(action);
+                            }
+                            catch (Win32Exception e)
+                            {
+                                if (!Messaging.Instance.EncounteredError)
+                                {
+                                    throw e;
+                                }
+                                // TODO: Review why this was clearing the error state when an exception had happened but an error was already encountered. That's weird.
+                                //else
+                                //{
+                                //    this.encounteredError = false;
+                                //}
+                            }
+                            this.actionName = null;
+                        }
+
+                        // Mark the validation session complete so we ignore any messages that MSI may fire
+                        // during session clean-up.
+                        this.validationSessionComplete = true;
+                    }
+                }
+            }
+            catch (Win32Exception e)
+            {
+                // avoid displaying errors twice since one may have already occurred in the UI handler
+                if (!Messaging.Instance.EncounteredError)
+                {
+                    if (0x6E == e.NativeErrorCode) // ERROR_OPEN_FAILED
+                    {
+                        // databaseFile is not passed since during light
+                        // this would be the temporary copy and there would be
+                        // no final output since the error occured; during smoke
+                        // they should know the path passed into smoke
+                        this.OnMessage(WixErrors.ValidationFailedToOpenDatabase());
+                    }
+                    else if (0x64D == e.NativeErrorCode)
+                    {
+                        this.OnMessage(WixErrors.ValidationFailedDueToLowMsiEngine());
+                    }
+                    else if (0x654 == e.NativeErrorCode)
+                    {
+                        this.OnMessage(WixErrors.ValidationFailedDueToInvalidPackage());
+                    }
+                    else if (0x658 == e.NativeErrorCode)
+                    {
+                        this.OnMessage(WixErrors.ValidationFailedDueToMultilanguageMergeModule());
+                    }
+                    else if (0x659 == e.NativeErrorCode)
+                    {
+                        this.OnMessage(WixWarnings.ValidationFailedDueToSystemPolicy());
+                    }
+                    else
+                    {
+                        string msgTemp = e.Message;
+
+                        if (null != this.actionName)
+                        {
+                            msgTemp = String.Concat("Action - '", this.actionName, "' ", e.Message);
+                        }
+
+                        this.OnMessage(WixErrors.Win32Exception(e.NativeErrorCode, msgTemp));
+                    }
+                }
+            }
+            finally
+            {
+                Installer.SetExternalUI(previousUIHandler, 0, IntPtr.Zero);
+                Installer.SetInternalUI(previousUILevel, ref previousHwnd);
+
+                this.validationSessionComplete = false; // no validation session at this point, so reset the completion flag.
+
+                mutex.ReleaseMutex();
+                this.cubeFiles.Clear();
+                this.extension.FinalizeValidator();
+            }
+        }
+
+        /// <summary>
+        /// Sends a message to the message delegate if there is one.
+        /// </summary>
+        /// <param name="mea">Message event arguments.</param>
+        public void OnMessage(MessageEventArgs e)
+        {
+            Messaging.Instance.OnMessage(e);
+            this.extension.OnMessage(e);
+        }
+
+        /// <summary>
+        /// The validation external UI handler.
+        /// </summary>
+        /// <param name="context">Pointer to an application context.
+        /// This parameter can be used for error checking.</param>
+        /// <param name="messageType">Specifies a combination of one message box style,
+        /// one message box icon type, one default button, and one installation message type.</param>
+        /// <param name="message">Specifies the message text.</param>
+        /// <returns>-1 for an error, 0 if no action was taken, 1 if OK, 3 to abort.</returns>
+        private int ValidationUIHandler(IntPtr context, uint messageType, string message)
+        {
+            try
+            {
+                // If we're getting messges during the validation session, send them to
+                // the extension. Otherwise, ignore the messages.
+                if (!this.validationSessionComplete)
+                {
+                    this.extension.Log(message, this.actionName);
+                }
+            }
+            catch (WixException ex)
+            {
+                this.OnMessage(ex.Error);
+            }
+
+            return 1;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/VerifyInterop.cs b/src/WixToolset.Core/VerifyInterop.cs
new file mode 100644
index 00000000..81fbec65
--- /dev/null
+++ b/src/WixToolset.Core/VerifyInterop.cs
@@ -0,0 +1,68 @@
+// 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
+{
+    using System;
+    using System.Collections;
+    using System.Runtime.CompilerServices;
+    using System.Runtime.InteropServices;
+
+    internal class VerifyInterop
+    {
+        internal const string GenericVerify2 = "00AAC56B-CD44-11d0-8CC2-00C04FC295EE";
+        internal const uint WTD_UI_NONE = 2;
+        internal const uint WTD_REVOKE_NONE = 0;
+        internal const uint WTD_CHOICE_CATALOG = 2;
+        internal const uint WTD_STATEACTION_VERIFY = 1;
+        internal const uint WTD_REVOCATION_CHECK_NONE = 0x10;
+        internal const int ErrorInsufficientBuffer = 122;
+
+        [StructLayout(LayoutKind.Sequential)]
+        internal struct WinTrustData
+        {
+            internal uint cbStruct;
+            internal IntPtr pPolicyCallbackData;
+            internal IntPtr pSIPClientData;
+            internal uint dwUIChoice;
+            internal uint fdwRevocationChecks;
+            internal uint dwUnionChoice;
+            internal IntPtr pCatalog;
+            internal uint dwStateAction;
+            internal IntPtr hWVTStateData;
+            [MarshalAs(UnmanagedType.LPWStr)]
+            internal string pwszURLReference;
+            internal uint dwProvFlags;
+            internal uint dwUIContext;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        internal struct WinTrustCatalogInfo
+        {
+            internal uint cbStruct;
+            internal uint dwCatalogVersion;
+            [MarshalAs(UnmanagedType.LPWStr)]
+            internal string pcwszCatalogFilePath;
+            [MarshalAs(UnmanagedType.LPWStr)]
+            internal string pcwszMemberTag;
+            [MarshalAs(UnmanagedType.LPWStr)]
+            internal string pcwszMemberFilePath;
+            internal IntPtr hMemberFile;
+            internal IntPtr pbCalculatedFileHash;
+            internal uint cbCalculatedFileHash;
+            internal IntPtr pcCatalogContext;
+        }
+
+        [DllImport("wintrust.dll", SetLastError = true)]
+        internal static extern long WinVerifyTrust(IntPtr windowHandle, ref Guid actionGuid, ref WinTrustData trustData);
+
+        [DllImport("wintrust.dll", SetLastError = true)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        internal static extern bool CryptCATAdminCalcHashFromFileHandle(
+            IntPtr fileHandle,
+            [In, Out]
+            ref uint hashSize,
+            [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 1)]
+            byte[] hashBytes,
+            uint flags);
+    }
+}
diff --git a/src/WixToolset.Core/WixComponentSearchInfo.cs b/src/WixToolset.Core/WixComponentSearchInfo.cs
new file mode 100644
index 00000000..dfd5d8ba
--- /dev/null
+++ b/src/WixToolset.Core/WixComponentSearchInfo.cs
@@ -0,0 +1,64 @@
+// 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
+{
+    using System;
+    using System.Xml;
+    using WixToolset.Data;
+
+    /// <summary>
+    /// Utility class for all WixComponentSearches.
+    /// </summary>
+    internal class WixComponentSearchInfo : WixSearchInfo
+    {
+        public WixComponentSearchInfo(Row row)
+            : this((string)row[0], (string)row[1], (string)row[2], (int)row[3])
+        {
+        }
+
+        public WixComponentSearchInfo(string id, string guid, string productCode, int attributes)
+            : base(id)
+        {
+            this.Guid = guid;
+            this.ProductCode = productCode;
+            this.Attributes = (WixComponentSearchAttributes)attributes;
+        }
+
+        public string Guid { get; private set; }
+        public string ProductCode { get; private set; }
+        public WixComponentSearchAttributes Attributes { get; private set; }
+
+        /// <summary>
+        /// Generates Burn manifest and ParameterInfo-style markup for a component search.
+        /// </summary>
+        /// <param name="writer"></param>
+        public override void WriteXml(XmlTextWriter writer)
+        {
+            writer.WriteStartElement("MsiComponentSearch");
+            this.WriteWixSearchAttributes(writer);
+
+            writer.WriteAttributeString("ComponentId", this.Guid);
+
+            if (!String.IsNullOrEmpty(this.ProductCode))
+            {
+                writer.WriteAttributeString("ProductCode", this.ProductCode);
+            }
+
+            if (0 != (this.Attributes & WixComponentSearchAttributes.KeyPath))
+            {
+                writer.WriteAttributeString("Type", "keyPath");
+            }
+            else if (0 != (this.Attributes & WixComponentSearchAttributes.State))
+            {
+                writer.WriteAttributeString("Type", "state");
+            }
+            else if (0 != (this.Attributes & WixComponentSearchAttributes.WantDirectory))
+            {
+                writer.WriteAttributeString("Type", "directory");
+            }
+
+            writer.WriteEndElement();
+        }
+    }
+
+}
diff --git a/src/WixToolset.Core/WixDistribution.cs b/src/WixToolset.Core/WixDistribution.cs
new file mode 100644
index 00000000..4ceb8982
--- /dev/null
+++ b/src/WixToolset.Core/WixDistribution.cs
@@ -0,0 +1,109 @@
+// 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.
+
+using System;
+using System.Diagnostics;
+using System.Reflection;
+using System.Resources;
+
+[assembly: NeutralResourcesLanguage("en-US")]
+
+namespace WixToolset
+{
+    /// <summary>
+    /// Distribution specific strings.
+    /// </summary>
+    internal static class WixDistribution
+    {
+        /// <summary>
+        /// News URL for the distribution.
+        /// </summary>
+        public static string NewsUrl = "http://wixtoolset.org/news/";
+
+        /// <summary>
+        /// Short product name for the distribution.
+        /// </summary>
+        public static string ShortProduct = "WiX Toolset";
+
+        /// <summary>
+        /// Support URL for the distribution.
+        /// </summary>
+        public static string SupportUrl = "http://wixtoolset.org/";
+
+        /// <summary>
+        /// Telemetry URL format for the distribution.
+        /// </summary>
+        public static string TelemetryUrlFormat = "http://wixtoolset.org/telemetry/v{0}/?r={1}";
+
+        /// <summary>
+        /// VS Extensions Landing page Url for the distribution.
+        /// </summary>
+        public static string VSExtensionsLandingUrl = "http://wixtoolset.org/releases/";
+
+        public static string ReplacePlaceholders(string original, Assembly assembly)
+        {
+            if (null != assembly)
+            {
+                FileVersionInfo fileVersion = FileVersionInfo.GetVersionInfo(assembly.Location);
+
+                original = original.Replace("[FileComments]", fileVersion.Comments);
+                original = original.Replace("[FileCopyright]", fileVersion.LegalCopyright);
+                original = original.Replace("[FileProductName]", fileVersion.ProductName);
+                original = original.Replace("[FileVersion]", fileVersion.FileVersion);
+
+                if (original.Contains("[FileVersionMajorMinor]"))
+                {
+                    Version version = new Version(fileVersion.FileVersion);
+                    original = original.Replace("[FileVersionMajorMinor]", String.Concat(version.Major, ".", version.Minor));
+                }
+
+                AssemblyCompanyAttribute company;
+                if (WixDistribution.TryGetAttribute(assembly, out company))
+                {
+                    original = original.Replace("[AssemblyCompany]", company.Company);
+                }
+
+                AssemblyCopyrightAttribute copyright;
+                if (WixDistribution.TryGetAttribute(assembly, out copyright))
+                {
+                    original = original.Replace("[AssemblyCopyright]", copyright.Copyright);
+                }
+
+                AssemblyDescriptionAttribute description;
+                if (WixDistribution.TryGetAttribute(assembly, out description))
+                {
+                    original = original.Replace("[AssemblyDescription]", description.Description);
+                }
+
+                AssemblyProductAttribute product;
+                if (WixDistribution.TryGetAttribute(assembly, out product))
+                {
+                    original = original.Replace("[AssemblyProduct]", product.Product);
+                }
+
+                AssemblyTitleAttribute title;
+                if (WixDistribution.TryGetAttribute(assembly, out title))
+                {
+                    original = original.Replace("[AssemblyTitle]", title.Title);
+                }
+            }
+
+            original = original.Replace("[NewsUrl]", WixDistribution.NewsUrl);
+            original = original.Replace("[ShortProduct]", WixDistribution.ShortProduct);
+            original = original.Replace("[SupportUrl]", WixDistribution.SupportUrl);
+            return original;
+        }
+
+        private static bool TryGetAttribute<T>(Assembly assembly, out T attribute) where T : Attribute
+        {
+            attribute = null;
+
+            object[] customAttributes = assembly.GetCustomAttributes(typeof(T), false);
+            if (null != customAttributes && 0 < customAttributes.Length)
+            {
+                attribute = customAttributes[0] as T;
+            }
+
+            return null != attribute;
+        }
+    }
+}
diff --git a/src/WixToolset.Core/WixDistributionSpecificStrings.Designer.cs b/src/WixToolset.Core/WixDistributionSpecificStrings.Designer.cs
new file mode 100644
index 00000000..841f6ca8
--- /dev/null
+++ b/src/WixToolset.Core/WixDistributionSpecificStrings.Designer.cs
@@ -0,0 +1,77 @@
+// 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 {
+    using System;
+    
+    
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // This class was auto-generated by the StronglyTypedResourceBuilder
+    // class via a tool like ResGen or Visual Studio.
+    // To add or remove a member, edit your .ResX file then rerun ResGen
+    // with the /str option, or rebuild your VS project.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "2.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    internal class WixDistributionSpecificStrings {
+        
+        private static global::System.Resources.ResourceManager resourceMan;
+        
+        private static global::System.Globalization.CultureInfo resourceCulture;
+        
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal WixDistributionSpecificStrings() {
+        }
+        
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Resources.ResourceManager ResourceManager {
+            get {
+                if (object.ReferenceEquals(resourceMan, null)) {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("WixToolset.WixDistributionSpecificStrings", typeof(WixDistributionSpecificStrings).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+        
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to 
+        ///For more information see: http://wix.sourceforge.net
+        ///.
+        /// </summary>
+        internal static string ToolsetHelpFooter {
+            get {
+                return ResourceManager.GetString("ToolsetHelpFooter", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to WiX {0} version {1}
+        ///Copyright (C) .NET Foundation and contributors. All rights reserved.
+        ///.
+        /// </summary>
+        internal static string ToolsetHelpHeader {
+            get {
+                return ResourceManager.GetString("ToolsetHelpHeader", resourceCulture);
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/WixDistributionSpecificStrings.resx b/src/WixToolset.Core/WixDistributionSpecificStrings.resx
new file mode 100644
index 00000000..7cca2d4e
--- /dev/null
+++ b/src/WixToolset.Core/WixDistributionSpecificStrings.resx
@@ -0,0 +1,130 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="ToolsetHelpFooter" xml:space="preserve">
+    <value>
+For more information see: [SupportUrl]
+</value>
+  </data>
+  <data name="ToolsetHelpHeader" xml:space="preserve">
+    <value>[AssemblyProduct] [AssemblyDescription] version [FileVersion]
+[AssemblyCopyright]
+</value>
+  </data>
+</root>
\ No newline at end of file
diff --git a/src/WixToolset.Core/WixFileSearchInfo.cs b/src/WixToolset.Core/WixFileSearchInfo.cs
new file mode 100644
index 00000000..e53f7bf7
--- /dev/null
+++ b/src/WixToolset.Core/WixFileSearchInfo.cs
@@ -0,0 +1,54 @@
+// 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
+{
+    using System;
+    using System.Xml;
+    using WixToolset.Data;
+
+    /// <summary>
+    /// Utility class for all WixFileSearches (file and directory searches).
+    /// </summary>
+    internal class WixFileSearchInfo : WixSearchInfo
+    {
+        public WixFileSearchInfo(Row row)
+            : this((string)row[0], (string)row[1], (int)row[9])
+        {
+        }
+
+        public WixFileSearchInfo(string id, string path, int attributes)
+            : base(id)
+        {
+            this.Path = path;
+            this.Attributes = (WixFileSearchAttributes)attributes;
+        }
+
+        public string Path { get; private set; }
+        public WixFileSearchAttributes Attributes { get; private set; }
+
+        /// <summary>
+        /// Generates Burn manifest and ParameterInfo-style markup for a file/directory search.
+        /// </summary>
+        /// <param name="writer"></param>
+        public override void WriteXml(XmlTextWriter writer)
+        {
+            writer.WriteStartElement((0 == (this.Attributes & WixFileSearchAttributes.IsDirectory)) ? "FileSearch" : "DirectorySearch");
+            this.WriteWixSearchAttributes(writer);
+            writer.WriteAttributeString("Path", this.Path);
+            if (WixFileSearchAttributes.WantExists == (this.Attributes & WixFileSearchAttributes.WantExists))
+            {
+                writer.WriteAttributeString("Type", "exists");
+            }
+            else if (WixFileSearchAttributes.WantVersion == (this.Attributes & WixFileSearchAttributes.WantVersion))
+            {
+                // Can never get here for DirectorySearch.
+                writer.WriteAttributeString("Type", "version");
+            }
+            else
+            {
+                writer.WriteAttributeString("Type", "path");
+            }
+            writer.WriteEndElement();
+        }
+    }
+}
diff --git a/src/WixToolset.Core/WixGenericMessageEventArgs.cs b/src/WixToolset.Core/WixGenericMessageEventArgs.cs
new file mode 100644
index 00000000..2c1d4705
--- /dev/null
+++ b/src/WixToolset.Core/WixGenericMessageEventArgs.cs
@@ -0,0 +1,45 @@
+// 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
+{
+    using System;
+    using System.Resources;
+    using WixToolset.Data;
+
+    /// <summary>
+    /// Generic event args for message events.
+    /// </summary>
+    public class WixGenericMessageEventArgs : MessageEventArgs
+    {
+        /// <summary>
+        /// Creates a new generc message event arg.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line numbers for the message.</param>
+        /// <param name="id">Id for the message.</param>
+        /// <param name="level">Level for the message.</param>
+        /// <param name="format">Format message for arguments.</param>
+        /// <param name="messageArgs">Arguments for the format string.</param>
+        public WixGenericMessageEventArgs(SourceLineNumber sourceLineNumbers, int id, MessageLevel level, string format, params object[] messageArgs)
+            : base(sourceLineNumbers, id, format, messageArgs)
+        {
+            base.Level = level;
+            base.ResourceManager = new GenericResourceManager();
+        }
+
+        /// <summary>
+        /// Private resource manager to return our format message as the "localized" string untouched.
+        /// </summary>
+        private class GenericResourceManager : ResourceManager
+        {
+            /// <summary>
+            /// Passes the "resource name" through as the format string.
+            /// </summary>
+            /// <param name="name">Format message that is passed in as the resource name.</param>
+            /// <returns>The name.</returns>
+            public override string GetString(string name)
+            {
+                return name;
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/WixProductSearchInfo.cs b/src/WixToolset.Core/WixProductSearchInfo.cs
new file mode 100644
index 00000000..4c57d8be
--- /dev/null
+++ b/src/WixToolset.Core/WixProductSearchInfo.cs
@@ -0,0 +1,67 @@
+// 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
+{
+    using System;
+    using System.Xml;
+    using WixToolset.Data;
+
+    /// <summary>
+    /// Utility class for all WixProductSearches.
+    /// </summary>
+    internal class WixProductSearchInfo : WixSearchInfo
+    {
+        public WixProductSearchInfo(Row row)
+            : this((string)row[0], (string)row[1], (int)row[2])
+        {
+        }
+
+        public WixProductSearchInfo(string id, string guid, int attributes)
+            : base(id)
+        {
+            this.Guid = guid;
+            this.Attributes = (WixProductSearchAttributes)attributes;
+        }
+
+        public string Guid { get; private set; }
+        public WixProductSearchAttributes Attributes { get; private set; }
+
+        /// <summary>
+        /// Generates Burn manifest and ParameterInfo-style markup for a product search.
+        /// </summary>
+        /// <param name="writer"></param>
+        public override void WriteXml(XmlTextWriter writer)
+        {
+            writer.WriteStartElement("MsiProductSearch");
+            this.WriteWixSearchAttributes(writer);
+
+            if (0 != (this.Attributes & WixProductSearchAttributes.UpgradeCode))
+            {
+                writer.WriteAttributeString("UpgradeCode", this.Guid);
+            }
+            else
+            {
+                writer.WriteAttributeString("ProductCode", this.Guid);
+            }
+
+            if (0 != (this.Attributes & WixProductSearchAttributes.Version))
+            {
+                writer.WriteAttributeString("Type", "version");
+            }
+            else if (0 != (this.Attributes & WixProductSearchAttributes.Language))
+            {
+                writer.WriteAttributeString("Type", "language");
+            }
+            else if (0 != (this.Attributes & WixProductSearchAttributes.State))
+            {
+                writer.WriteAttributeString("Type", "state");
+            }
+            else if (0 != (this.Attributes & WixProductSearchAttributes.Assignment))
+            {
+                writer.WriteAttributeString("Type", "assignment");
+            }
+
+            writer.WriteEndElement();
+        }
+    }
+}
diff --git a/src/WixToolset.Core/WixRegistrySearchInfo.cs b/src/WixToolset.Core/WixRegistrySearchInfo.cs
new file mode 100644
index 00000000..e8d7ce9b
--- /dev/null
+++ b/src/WixToolset.Core/WixRegistrySearchInfo.cs
@@ -0,0 +1,92 @@
+// 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
+{
+    using System;
+    using System.Xml;
+    using WixToolset.Data;
+
+    /// <summary>
+    /// Utility class for all WixRegistrySearches.
+    /// </summary>
+    internal class WixRegistrySearchInfo : WixSearchInfo
+    {
+        public WixRegistrySearchInfo(Row row)
+            : this((string)row[0], (int)row[1], (string)row[2], (string)row[3], (int)row[4])
+        {
+        }
+
+        public WixRegistrySearchInfo(string id, int root, string key, string value, int attributes)
+            : base(id)
+        {
+            this.Root = root;
+            this.Key = key;
+            this.Value = value;
+            this.Attributes = (WixRegistrySearchAttributes)attributes;
+        }
+
+        public int Root { get; private set; }
+        public string Key { get; private set; }
+        public string Value { get; private set; }
+        public WixRegistrySearchAttributes Attributes { get; private set; }
+
+        /// <summary>
+        /// Generates Burn manifest and ParameterInfo-style markup for a registry search.
+        /// </summary>
+        /// <param name="writer"></param>
+        public override void WriteXml(XmlTextWriter writer)
+        {
+            writer.WriteStartElement("RegistrySearch");
+            this.WriteWixSearchAttributes(writer);
+
+            switch (this.Root)
+            {
+                case Core.Native.MsiInterop.MsidbRegistryRootClassesRoot:
+                    writer.WriteAttributeString("Root", "HKCR");
+                    break;
+                case Core.Native.MsiInterop.MsidbRegistryRootCurrentUser:
+                    writer.WriteAttributeString("Root", "HKCU");
+                    break;
+                case Core.Native.MsiInterop.MsidbRegistryRootLocalMachine:
+                    writer.WriteAttributeString("Root", "HKLM");
+                    break;
+                case Core.Native.MsiInterop.MsidbRegistryRootUsers:
+                    writer.WriteAttributeString("Root", "HKU");
+                    break;
+            }
+
+            writer.WriteAttributeString("Key", this.Key);
+
+            if (!String.IsNullOrEmpty(this.Value))
+            {
+                writer.WriteAttributeString("Value", this.Value);
+            }
+
+            bool existenceOnly = 0 != (this.Attributes & WixRegistrySearchAttributes.WantExists);
+
+            writer.WriteAttributeString("Type", existenceOnly ? "exists" : "value");
+
+            if (0 != (this.Attributes & WixRegistrySearchAttributes.Win64))
+            {
+                writer.WriteAttributeString("Win64", "yes");
+            }
+
+            if (!existenceOnly)
+            {
+                if (0 != (this.Attributes & WixRegistrySearchAttributes.ExpandEnvironmentVariables))
+                {
+                    writer.WriteAttributeString("ExpandEnvironment", "yes");
+                }
+
+                // We *always* say this is VariableType="string". If we end up
+                // needing to be more specific, we will have to expand the "Format"
+                // attribute to allow "number" and "version".
+
+                writer.WriteAttributeString("VariableType", "string");
+            }
+
+            writer.WriteEndElement();
+        }
+    }
+
+}
diff --git a/src/WixToolset.Core/WixSearchInfo.cs b/src/WixToolset.Core/WixSearchInfo.cs
new file mode 100644
index 00000000..906365a2
--- /dev/null
+++ b/src/WixToolset.Core/WixSearchInfo.cs
@@ -0,0 +1,53 @@
+// 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
+{
+    using System;
+    using System.Diagnostics;
+    using System.Xml;
+    using WixToolset.Data;
+
+    /// <summary>
+    /// Utility base class for all WixSearches.
+    /// </summary>
+    internal abstract class WixSearchInfo
+    {
+        public WixSearchInfo(string id)
+        {
+            this.Id = id;
+        }
+
+        public void AddWixSearchRowInfo(Row row)
+        {
+            Debug.Assert((string)row[0] == Id);
+            Variable = (string)row[1];
+            Condition = (string)row[2];
+        }
+
+        public string Id { get; private set; }
+        public string Variable { get; private set; }
+        public string Condition { get; private set; }
+
+        /// <summary>
+        /// Generates Burn manifest and ParameterInfo-style markup a search.
+        /// </summary>
+        /// <param name="writer"></param>
+        public virtual void WriteXml(XmlTextWriter writer)
+        {
+        }
+
+        /// <summary>
+        /// Writes attributes common to all WixSearch elements.
+        /// </summary>
+        /// <param name="writer"></param>
+        protected void WriteWixSearchAttributes(XmlTextWriter writer)
+        {
+            writer.WriteAttributeString("Id", this.Id);
+            writer.WriteAttributeString("Variable", this.Variable);
+            if (!String.IsNullOrEmpty(this.Condition))
+            {
+                writer.WriteAttributeString("Condition", this.Condition);
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/WixStrings.Designer.cs b/src/WixToolset.Core/WixStrings.Designer.cs
new file mode 100644
index 00000000..4ba9381a
--- /dev/null
+++ b/src/WixToolset.Core/WixStrings.Designer.cs
@@ -0,0 +1,442 @@
+// 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 {
+    using System;
+    
+    
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // This class was auto-generated by the StronglyTypedResourceBuilder
+    // class via a tool like ResGen or Visual Studio.
+    // To add or remove a member, edit your .ResX file then rerun ResGen
+    // with the /str option, or rebuild your VS project.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    internal class WixStrings {
+        
+        private static global::System.Resources.ResourceManager resourceMan;
+        
+        private static global::System.Globalization.CultureInfo resourceCulture;
+        
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal WixStrings() {
+        }
+        
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Resources.ResourceManager ResourceManager {
+            get {
+                if (object.ReferenceEquals(resourceMan, null)) {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("WixToolset.WixStrings", typeof(WixStrings).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+        
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Cannot index into a FileRowCollection that allows duplicate FileIds.
+        /// </summary>
+        internal static string EXP_CannotIndexIntoFileRowCollection {
+            get {
+                return ResourceManager.GetString("EXP_CannotIndexIntoFileRowCollection", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The value &apos;{0}&apos; is not a legal identifier and therefore cannot be modularized..
+        /// </summary>
+        internal static string EXP_CannotModularizeIllegalID {
+            get {
+                return ResourceManager.GetString("EXP_CannotModularizeIllegalID", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Cannot set column &apos;{0}&apos; with value {1} because it is greater than the maximum allowed value for this column, {2}..
+        /// </summary>
+        internal static string EXP_CannotSetColumnWithValueGreaterThanMaxValue {
+            get {
+                return ResourceManager.GetString("EXP_CannotSetColumnWithValueGreaterThanMaxValue", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Cannot set column &apos;{0}&apos; with value {1} because it is less than the minimum allowed value for this column, {2}..
+        /// </summary>
+        internal static string EXP_CannotSetColumnWithValueLessThanMinValue {
+            get {
+                return ResourceManager.GetString("EXP_CannotSetColumnWithValueLessThanMinValue", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to A Merge table FileCompression column cannot be set to the invalid value &apos;{0}&apos;..
+        /// </summary>
+        internal static string EXP_CannotSetMergeTableFileCompressionColumnToInvalidValue {
+            get {
+                return ResourceManager.GetString("EXP_CannotSetMergeTableFileCompressionColumnToInvalidValue", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Cannot set column &apos;{0}&apos; with a null value because this is a required field..
+        /// </summary>
+        internal static string EXP_CannotSetNullOnRequiredField {
+            get {
+                return ResourceManager.GetString("EXP_CannotSetNullOnRequiredField", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Cannot set number column &apos;{0}&apos; with a value of type &apos;{1}&apos;..
+        /// </summary>
+        internal static string EXP_CannotSetNumberColumnWithValueOfType {
+            get {
+                return ResourceManager.GetString("EXP_CannotSetNumberColumnWithValueOfType", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Cannot set string column &apos;{0}&apos; with a value of type &apos;{1}&apos;..
+        /// </summary>
+        internal static string EXP_CannotSetStringColumnWithValueOfType {
+            get {
+                return ResourceManager.GetString("EXP_CannotSetStringColumnWithValueOfType", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Could not determine ProductCode from transform summary information.
+        /// </summary>
+        internal static string EXP_CouldnotDetermineProductCodeFromTransformSummaryInfo {
+            get {
+                return ResourceManager.GetString("EXP_CouldnotDetermineProductCodeFromTransformSummaryInfo", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Could not find a unique identifier for the given resource name..
+        /// </summary>
+        internal static string EXP_CouldnotFileUniqueIDForResourceName {
+            get {
+                return ResourceManager.GetString("EXP_CouldnotFileUniqueIDForResourceName", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Didn&apos;t find duplicated symbol..
+        /// </summary>
+        internal static string EXP_DidnotFindDuplicateSymbol {
+            get {
+                return ResourceManager.GetString("EXP_DidnotFindDuplicateSymbol", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Expected ComplexReference type..
+        /// </summary>
+        internal static string EXP_ExpectedComplexReferenceType {
+            get {
+                return ResourceManager.GetString("EXP_ExpectedComplexReferenceType", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Found an ActionRow with a non-existent {0} action: {1}..
+        /// </summary>
+        internal static string EXP_FoundActionRowWinNonExistentAction {
+            get {
+                return ResourceManager.GetString("EXP_FoundActionRowWinNonExistentAction", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Found an ActionRow with no Sequence, Before, or After column set..
+        /// </summary>
+        internal static string EXP_FoundActionRowWithNoSequenceBeforeOrAfterColumnSet {
+            get {
+                return ResourceManager.GetString("EXP_FoundActionRowWithNoSequenceBeforeOrAfterColumnSet", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Illegal arguments passed..
+        /// </summary>
+        internal static string EXP_IllegalArgumentsPassed {
+            get {
+                return ResourceManager.GetString("EXP_IllegalArgumentsPassed", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Invalid table name passed into GenerateIdentifier..
+        /// </summary>
+        internal static string EXP_InvalidTableNamePassed {
+            get {
+                return ResourceManager.GetString("EXP_InvalidTableNamePassed", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to A Merge table FileCompression column contains an invalid value &apos;{0}&apos;..
+        /// </summary>
+        internal static string EXP_MergeTableFileCompressionColumnContainsInvalidValue {
+            get {
+                return ResourceManager.GetString("EXP_MergeTableFileCompressionColumnContainsInvalidValue", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Multiple harvester extensions specified..
+        /// </summary>
+        internal static string EXP_MultipleHarvesterExtensionsSpecified {
+            get {
+                return ResourceManager.GetString("EXP_MultipleHarvesterExtensionsSpecified", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The other object is not a FileRow..
+        /// </summary>
+        internal static string EXP_OtherObjectIsNotFileRow {
+            get {
+                return ResourceManager.GetString("EXP_OtherObjectIsNotFileRow", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Transform authored into multiple Media &apos;{0}&apos; and &apos;{1}&apos;..
+        /// </summary>
+        internal static string EXP_TransformAuthoredIntoMultipleMedia {
+            get {
+                return ResourceManager.GetString("EXP_TransformAuthoredIntoMultipleMedia", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Unexpected complex reference child type: {0}.
+        /// </summary>
+        internal static string EXP_UnexpectedComplexReferenceChildType {
+            get {
+                return ResourceManager.GetString("EXP_UnexpectedComplexReferenceChildType", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Unexpected entry section type: {0}.
+        /// </summary>
+        internal static string EXP_UnexpectedEntrySectionType {
+            get {
+                return ResourceManager.GetString("EXP_UnexpectedEntrySectionType", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Encountered an unexpected error while merging &apos;{0}&apos;. More information about the merge and the failure can be found in the merge log: &apos;{1}&apos;.
+        /// </summary>
+        internal static string EXP_UnexpectedMergerErrorInSourceFile {
+            get {
+                return ResourceManager.GetString("EXP_UnexpectedMergerErrorInSourceFile", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Encountered an unexpected merge error of type &apos;{0}&apos; for which there is currently no error message to display.  More information about the merge and the failure can be found in the merge log: &apos;{1}&apos;.
+        /// </summary>
+        internal static string EXP_UnexpectedMergerErrorWithType {
+            get {
+                return ResourceManager.GetString("EXP_UnexpectedMergerErrorWithType", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Unknown control attribute: &apos;{0}&apos;..
+        /// </summary>
+        internal static string EXP_UnknowControlAttribute {
+            get {
+                return ResourceManager.GetString("EXP_UnknowControlAttribute", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Unknown column type: {0}.
+        /// </summary>
+        internal static string EXP_UnknownColumnType {
+            get {
+                return ResourceManager.GetString("EXP_UnknownColumnType", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Unknown compression level type: {0}.
+        /// </summary>
+        internal static string EXP_UnknownCompressionLevelType {
+            get {
+                return ResourceManager.GetString("EXP_UnknownCompressionLevelType", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Unknown custom column category &apos;{0}&apos;..
+        /// </summary>
+        internal static string EXP_UnknownCustomColumnCategory {
+            get {
+                return ResourceManager.GetString("EXP_UnknownCustomColumnCategory", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Unknown custom column modularization type &apos;{0}&apos;..
+        /// </summary>
+        internal static string EXP_UnknownCustomColumnModularizationType {
+            get {
+                return ResourceManager.GetString("EXP_UnknownCustomColumnModularizationType", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Unknown custom column type &apos;{0}&apos;..
+        /// </summary>
+        internal static string EXP_UnknownCustomColumnType {
+            get {
+                return ResourceManager.GetString("EXP_UnknownCustomColumnType", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Unknown output type..
+        /// </summary>
+        internal static string EXP_UnknownOutputType {
+            get {
+                return ResourceManager.GetString("EXP_UnknownOutputType", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Unknown permission attribute &apos;{0}&apos;..
+        /// </summary>
+        internal static string EXP_UnknownPermissionAttribute {
+            get {
+                return ResourceManager.GetString("EXP_UnknownPermissionAttribute", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Unknown platform enumeration &apos;{0}&apos; encountered..
+        /// </summary>
+        internal static string EXP_UnknownPlatformEnum {
+            get {
+                return ResourceManager.GetString("EXP_UnknownPlatformEnum", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Unknown sequence table..
+        /// </summary>
+        internal static string EXP_UnknowSequenceTable {
+            get {
+                return ResourceManager.GetString("EXP_UnknowSequenceTable", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to The table {0} is not supported..
+        /// </summary>
+        internal static string EXP_UnsupportedTable {
+            get {
+                return ResourceManager.GetString("EXP_UnsupportedTable", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to {0}({1}).
+        /// </summary>
+        internal static string Format_FirstLineNumber {
+            get {
+                return ResourceManager.GetString("Format_FirstLineNumber", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to {0}.
+        /// </summary>
+        internal static string Format_InfoMessage {
+            get {
+                return ResourceManager.GetString("Format_InfoMessage", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to {0}: line {1}.
+        /// </summary>
+        internal static string Format_LineNumber {
+            get {
+                return ResourceManager.GetString("Format_LineNumber", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to {0} : {1} {2}{3:0000} : {4}.
+        /// </summary>
+        internal static string Format_NonInfoMessage {
+            get {
+                return ResourceManager.GetString("Format_NonInfoMessage", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Source trace:{0}.
+        /// </summary>
+        internal static string INF_SourceTrace {
+            get {
+                return ResourceManager.GetString("INF_SourceTrace", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to at {0}{1}.
+        /// </summary>
+        internal static string INF_SourceTraceLocation {
+            get {
+                return ResourceManager.GetString("INF_SourceTraceLocation", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to error.
+        /// </summary>
+        internal static string MessageType_Error {
+            get {
+                return ResourceManager.GetString("MessageType_Error", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to warning.
+        /// </summary>
+        internal static string MessageType_Warning {
+            get {
+                return ResourceManager.GetString("MessageType_Warning", resourceCulture);
+            }
+        }
+    }
+}
diff --git a/src/WixToolset.Core/WixStrings.resx b/src/WixToolset.Core/WixStrings.resx
new file mode 100644
index 00000000..3fbf639e
--- /dev/null
+++ b/src/WixToolset.Core/WixStrings.resx
@@ -0,0 +1,249 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="EXP_CannotIndexIntoFileRowCollection" xml:space="preserve">
+    <value>Cannot index into a FileRowCollection that allows duplicate FileIds</value>
+  </data>
+  <data name="EXP_CannotModularizeIllegalID" xml:space="preserve">
+    <value>The value '{0}' is not a legal identifier and therefore cannot be modularized.</value>
+  </data>
+  <data name="EXP_CannotSetColumnWithValueGreaterThanMaxValue" xml:space="preserve">
+    <value>Cannot set column '{0}' with value {1} because it is greater than the maximum allowed value for this column, {2}.</value>
+  </data>
+  <data name="EXP_CannotSetColumnWithValueLessThanMinValue" xml:space="preserve">
+    <value>Cannot set column '{0}' with value {1} because it is less than the minimum allowed value for this column, {2}.</value>
+  </data>
+  <data name="EXP_CannotSetMergeTableFileCompressionColumnToInvalidValue" xml:space="preserve">
+    <value>A Merge table FileCompression column cannot be set to the invalid value '{0}'.</value>
+  </data>
+  <data name="EXP_CannotSetNullOnRequiredField" xml:space="preserve">
+    <value>Cannot set column '{0}' with a null value because this is a required field.</value>
+  </data>
+  <data name="EXP_CannotSetNumberColumnWithValueOfType" xml:space="preserve">
+    <value>Cannot set number column '{0}' with a value of type '{1}'.</value>
+  </data>
+  <data name="EXP_CannotSetStringColumnWithValueOfType" xml:space="preserve">
+    <value>Cannot set string column '{0}' with a value of type '{1}'.</value>
+  </data>
+  <data name="EXP_CouldnotDetermineProductCodeFromTransformSummaryInfo" xml:space="preserve">
+    <value>Could not determine ProductCode from transform summary information</value>
+  </data>
+  <data name="EXP_CouldnotFileUniqueIDForResourceName" xml:space="preserve">
+    <value>Could not find a unique identifier for the given resource name.</value>
+  </data>
+  <data name="EXP_DidnotFindDuplicateSymbol" xml:space="preserve">
+    <value>Didn't find duplicated symbol.</value>
+  </data>
+  <data name="EXP_ExpectedComplexReferenceType" xml:space="preserve">
+    <value>Expected ComplexReference type.</value>
+  </data>
+  <data name="EXP_FoundActionRowWinNonExistentAction" xml:space="preserve">
+    <value>Found an ActionRow with a non-existent {0} action: {1}.</value>
+  </data>
+  <data name="EXP_FoundActionRowWithNoSequenceBeforeOrAfterColumnSet" xml:space="preserve">
+    <value>Found an ActionRow with no Sequence, Before, or After column set.</value>
+  </data>
+  <data name="EXP_IllegalArgumentsPassed" xml:space="preserve">
+    <value>Illegal arguments passed.</value>
+  </data>
+  <data name="EXP_InvalidTableNamePassed" xml:space="preserve">
+    <value>Invalid table name passed into GenerateIdentifier.</value>
+  </data>
+  <data name="EXP_MergeTableFileCompressionColumnContainsInvalidValue" xml:space="preserve">
+    <value>A Merge table FileCompression column contains an invalid value '{0}'.</value>
+  </data>
+  <data name="EXP_MultipleHarvesterExtensionsSpecified" xml:space="preserve">
+    <value>Multiple harvester extensions specified.</value>
+  </data>
+  <data name="EXP_OtherObjectIsNotFileRow" xml:space="preserve">
+    <value>The other object is not a FileRow.</value>
+  </data>
+  <data name="EXP_TransformAuthoredIntoMultipleMedia" xml:space="preserve">
+    <value>Transform authored into multiple Media '{0}' and '{1}'.</value>
+  </data>
+  <data name="EXP_UnexpectedComplexReferenceChildType" xml:space="preserve">
+    <value>Unexpected complex reference child type: {0}</value>
+  </data>
+  <data name="EXP_UnexpectedEntrySectionType" xml:space="preserve">
+    <value>Unexpected entry section type: {0}</value>
+  </data>
+  <data name="EXP_UnexpectedMergerErrorInSourceFile" xml:space="preserve">
+    <value>Encountered an unexpected error while merging '{0}'. More information about the merge and the failure can be found in the merge log: '{1}'</value>
+  </data>
+  <data name="EXP_UnexpectedMergerErrorWithType" xml:space="preserve">
+    <value>Encountered an unexpected merge error of type '{0}' for which there is currently no error message to display.  More information about the merge and the failure can be found in the merge log: '{1}'</value>
+  </data>
+  <data name="EXP_UnknowControlAttribute" xml:space="preserve">
+    <value>Unknown control attribute: '{0}'.</value>
+  </data>
+  <data name="EXP_UnknownColumnType" xml:space="preserve">
+    <value>Unknown column type: {0}</value>
+  </data>
+  <data name="EXP_UnknownCompressionLevelType" xml:space="preserve">
+    <value>Unknown compression level type: {0}</value>
+  </data>
+  <data name="EXP_UnknownCustomColumnCategory" xml:space="preserve">
+    <value>Unknown custom column category '{0}'.</value>
+  </data>
+  <data name="EXP_UnknownCustomColumnModularizationType" xml:space="preserve">
+    <value>Unknown custom column modularization type '{0}'.</value>
+  </data>
+  <data name="EXP_UnknownCustomColumnType" xml:space="preserve">
+    <value>Unknown custom column type '{0}'.</value>
+  </data>
+  <data name="EXP_UnknownOutputType" xml:space="preserve">
+    <value>Unknown output type.</value>
+  </data>
+  <data name="EXP_UnknownPermissionAttribute" xml:space="preserve">
+    <value>Unknown permission attribute '{0}'.</value>
+  </data>
+  <data name="EXP_UnknowSequenceTable" xml:space="preserve">
+    <value>Unknown sequence table.</value>
+  </data>
+  <data name="EXP_UnknownPlatformEnum" xml:space="preserve">
+    <value>Unknown platform enumeration '{0}' encountered.</value>
+  </data>
+  <data name="EXP_UnsupportedTable" xml:space="preserve">
+    <value>The table {0} is not supported.</value>
+  </data>
+  <data name="Format_FirstLineNumber" xml:space="preserve">
+    <value>{0}({1})</value>
+  </data>
+  <data name="Format_InfoMessage" xml:space="preserve">
+    <value>{0}</value>
+  </data>
+  <data name="Format_LineNumber" xml:space="preserve">
+    <value>{0}: line {1}</value>
+  </data>
+  <data name="Format_NonInfoMessage" xml:space="preserve">
+    <value>{0} : {1} {2}{3:0000} : {4}</value>
+  </data>
+  <data name="INF_SourceTrace" xml:space="preserve">
+    <value>Source trace:{0}</value>
+  </data>
+  <data name="INF_SourceTraceLocation" xml:space="preserve">
+    <value>at {0}{1}</value>
+  </data>
+  <data name="MessageType_Error" xml:space="preserve">
+    <value>error</value>
+  </data>
+  <data name="MessageType_Warning" xml:space="preserve">
+    <value>warning</value>
+  </data>
+</root>
\ No newline at end of file
diff --git a/src/WixToolset.Core/WixToolset.Core.csproj b/src/WixToolset.Core/WixToolset.Core.csproj
new file mode 100644
index 00000000..3db31e4d
--- /dev/null
+++ b/src/WixToolset.Core/WixToolset.Core.csproj
@@ -0,0 +1,46 @@
+<?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>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <Description></Description>
+    <Title>WiX Toolset Core</Title>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <NoWarn>NU1701</NoWarn>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <MsgGenSource Include="Data\messages.xml">
+      <ResourcesLogicalName>WixToolset.Core.Data.messages.resources</ResourcesLogicalName>
+    </MsgGenSource>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="$(WixToolsetRootFolder)\Data\src\WixToolset.Data\WixToolset.Data.csproj" Condition=" '$(Configuration)' == 'Debug' And Exists('$(WixToolsetRootFolder)\Data\src\WixToolset.Data\WixToolset.Data.csproj') " />
+    <PackageReference Include="WixToolset.Data" Version="4.0.*" Condition=" '$(Configuration)' == 'Release' Or !Exists('$(WixToolsetRootFolder)\Data\src\WixToolset.Data\WixToolset.Data.csproj') " />
+
+    <ProjectReference Include="$(WixToolsetRootFolder)\Extensibility\src\WixToolset.Extensibility\WixToolset.Extensibility.csproj" Condition=" '$(Configuration)' == 'Debug' And Exists('$(WixToolsetRootFolder)\Extensibility\src\WixToolset.Extensibility\WixToolset.Extensibility.csproj') " />
+    <PackageReference Include="WixToolset.Extensibility" Version="4.0.*" Condition=" '$(Configuration)' == 'Release' Or !Exists('$(WixToolsetRootFolder)\Extensibility\src\WixToolset.Extensibility\WixToolset.Extensibility.csproj') " />
+
+    <ProjectReference Include="$(WixToolsetRootFolder)\Core.Native\src\WixToolset.Core.Native\WixToolset.Core.Native.csproj" Condition=" '$(Configuration)' == 'Debug' And Exists('$(WixToolsetRootFolder)\Core.Native\src\WixToolset.Core.Native\WixToolset.Core.Native.csproj') " />
+    <PackageReference Include="WixToolset.Core.Native" Version="4.0.*" Condition=" '$(Configuration)' == 'Release' Or !Exists('$(WixToolsetRootFolder)\Core.Native\src\WixToolset.Core.Native\WixToolset.Core.Native.csproj') " />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="WixToolset.Dtf.Resources" Version="4.0.*" />
+    <PackageReference Include="WixToolset.Dtf.WindowsInstaller" Version="4.0.*" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="System.IO.FileSystem.AccessControl" Version="4.4.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Nerdbank.GitVersioning" Version="2.0.41" PrivateAssets="all" />
+    <PackageReference Include="WixBuildTools.MsgGen" Version="4.0.*" PrivateAssets="all" />
+    <PackageReference Include="WixBuildTools.XsdGen" Version="4.0.*" PrivateAssets="all" />
+  </ItemGroup>
+</Project>
diff --git a/src/WixToolset.Core/WixVariableResolver.cs b/src/WixToolset.Core/WixVariableResolver.cs
new file mode 100644
index 00000000..921ff1e3
--- /dev/null
+++ b/src/WixToolset.Core/WixVariableResolver.cs
@@ -0,0 +1,337 @@
+// 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
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Diagnostics.CodeAnalysis;
+    using System.Globalization;
+    using System.Text;
+    using System.Text.RegularExpressions;
+    using WixToolset.Data;
+    using WixToolset.Data.Rows;
+
+    /// <summary>
+    /// WiX variable resolver.
+    /// </summary>
+    public sealed class WixVariableResolver
+    {
+        private Localizer localizer;
+        private Dictionary<string, string> wixVariables;
+
+        /// <summary>
+        /// Instantiate a new WixVariableResolver.
+        /// </summary>
+        public WixVariableResolver()
+        {
+            this.wixVariables = new Dictionary<string, string>();
+        }
+
+        /// <summary>
+        /// Gets or sets the localizer.
+        /// </summary>
+        /// <value>The localizer.</value>
+        public Localizer Localizer
+        {
+            get { return this.localizer; }
+            set { this.localizer = value; }
+        }
+
+        /// <summary>
+        /// Gets the count of variables added to the resolver.
+        /// </summary>
+        public int VariableCount
+        {
+            get { return this.wixVariables.Count; }
+        }
+
+        /// <summary>
+        /// Add a variable.
+        /// </summary>
+        /// <param name="name">The name of the variable.</param>
+        /// <param name="value">The value of the variable.</param>
+        public void AddVariable(string name, string value)
+        {
+            try
+            {
+                this.wixVariables.Add(name, value);
+            }
+            catch (ArgumentException)
+            {
+                Messaging.Instance.OnMessage(WixErrors.WixVariableCollision(null, name));
+            }
+        }
+
+        /// <summary>
+        /// Add a variable.
+        /// </summary>
+        /// <param name="wixVariableRow">The WixVariableRow to add.</param>
+        public void AddVariable(WixVariableRow wixVariableRow)
+        {
+            try
+            {
+                this.wixVariables.Add(wixVariableRow.Id, wixVariableRow.Value);
+            }
+            catch (ArgumentException)
+            {
+                if (!wixVariableRow.Overridable) // collision
+                {
+                    Messaging.Instance.OnMessage(WixErrors.WixVariableCollision(wixVariableRow.SourceLineNumbers, wixVariableRow.Id));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Resolve the wix variables in a value.
+        /// </summary>
+        /// <param name="sourceLineNumbers">The source line information for the value.</param>
+        /// <param name="value">The value to resolve.</param>
+        /// <param name="localizationOnly">true to only resolve localization variables; false otherwise.</param>
+        /// <returns>The resolved value.</returns>
+        public string ResolveVariables(SourceLineNumber sourceLineNumbers, string value, bool localizationOnly)
+        {
+            bool isDefault = false;
+            bool delayedResolve = false;
+
+            return this.ResolveVariables(sourceLineNumbers, value, localizationOnly, ref isDefault, ref delayedResolve);
+        }
+
+        /// <summary>
+        /// Resolve the wix variables in a value.
+        /// </summary>
+        /// <param name="sourceLineNumbers">The source line information for the value.</param>
+        /// <param name="value">The value to resolve.</param>
+        /// <param name="localizationOnly">true to only resolve localization variables; false otherwise.</param>
+        /// <param name="isDefault">true if the resolved value was the default.</param>
+        /// <returns>The resolved value.</returns>
+        public string ResolveVariables(SourceLineNumber sourceLineNumbers, string value, bool localizationOnly, ref bool isDefault)
+        {
+            bool delayedResolve = false;
+
+            return this.ResolveVariables(sourceLineNumbers, value, localizationOnly, ref isDefault, ref delayedResolve);
+        }
+
+        /// <summary>
+        /// Resolve the wix variables in a value.
+        /// </summary>
+        /// <param name="sourceLineNumbers">The source line information for the value.</param>
+        /// <param name="value">The value to resolve.</param>
+        /// <param name="localizationOnly">true to only resolve localization variables; false otherwise.</param>
+        /// <param name="errorOnUnknown">true if unknown variables should throw errors.</param>
+        /// <param name="isDefault">true if the resolved value was the default.</param>
+        /// <param name="delayedResolve">true if the value has variables that cannot yet be resolved.</param>
+        /// <returns>The resolved value.</returns>
+        public string ResolveVariables(SourceLineNumber sourceLineNumbers, string value, bool localizationOnly, ref bool isDefault, ref bool delayedResolve)
+        {
+            return this.ResolveVariables(sourceLineNumbers, value, localizationOnly, true, ref isDefault, ref delayedResolve);
+        }
+
+        /// <summary>
+        /// Resolve the wix variables in a value.
+        /// </summary>
+        /// <param name="sourceLineNumbers">The source line information for the value.</param>
+        /// <param name="value">The value to resolve.</param>
+        /// <param name="localizationOnly">true to only resolve localization variables; false otherwise.</param>
+        /// <param name="errorOnUnknown">true if unknown variables should throw errors.</param>
+        /// <param name="isDefault">true if the resolved value was the default.</param>
+        /// <param name="delayedResolve">true if the value has variables that cannot yet be resolved.</param>
+        /// <returns>The resolved value.</returns>
+        public string ResolveVariables(SourceLineNumber sourceLineNumbers, string value, bool localizationOnly, bool errorOnUnknown, ref bool isDefault, ref bool delayedResolve)
+        {
+            MatchCollection matches = Common.WixVariableRegex.Matches(value);
+
+            // the value is the default unless its substituted further down
+            isDefault = true;
+            delayedResolve = false;
+
+            if (0 < matches.Count)
+            {
+                StringBuilder sb = new StringBuilder(value);
+
+                // notice how this code walks backward through the list
+                // because it modifies the string as we through it
+                for (int i = matches.Count - 1; 0 <= i; i--)
+                {
+                    string variableNamespace = matches[i].Groups["namespace"].Value;
+                    string variableId = matches[i].Groups["fullname"].Value;
+                    string variableDefaultValue = null;
+
+                    // get the default value if one was specified
+                    if (matches[i].Groups["value"].Success)
+                    {
+                        variableDefaultValue = matches[i].Groups["value"].Value;
+
+                        // localization variables to not support inline default values
+                        if ("loc" == variableNamespace)
+                        {
+                            Messaging.Instance.OnMessage(WixErrors.IllegalInlineLocVariable(sourceLineNumbers, variableId, variableDefaultValue));
+                        }
+                    }
+
+                    // get the scope if one was specified
+                    if (matches[i].Groups["scope"].Success)
+                    {
+                        if ("bind" == variableNamespace)
+                        {
+                            variableId = matches[i].Groups["name"].Value;
+                        }
+                    }
+
+                    // check for an escape sequence of !! indicating the match is not a variable expression
+                    if (0 < matches[i].Index && '!' == sb[matches[i].Index - 1])
+                    {
+                        if (!localizationOnly)
+                        {
+                            sb.Remove(matches[i].Index - 1, 1);
+                        }
+                    }
+                    else
+                    {
+                        string resolvedValue = null;
+
+                        if ("loc" == variableNamespace)
+                        {
+                            // warn about deprecated syntax of $(loc.var)
+                            if ('$' == sb[matches[i].Index])
+                            {
+                                Messaging.Instance.OnMessage(WixWarnings.DeprecatedLocalizationVariablePrefix(sourceLineNumbers, variableId));
+                            }
+
+                            if (null != this.localizer)
+                            {
+                                resolvedValue = this.localizer.GetLocalizedValue(variableId);
+                            }
+                        }
+                        else if (!localizationOnly && "wix" == variableNamespace)
+                        {
+                            // illegal syntax of $(wix.var)
+                            if ('$' == sb[matches[i].Index])
+                            {
+                                Messaging.Instance.OnMessage(WixErrors.IllegalWixVariablePrefix(sourceLineNumbers, variableId));
+                            }
+                            else
+                            {
+                                if (this.wixVariables.TryGetValue(variableId, out resolvedValue))
+                                {
+                                    resolvedValue = resolvedValue ?? String.Empty;
+                                    isDefault = false;
+                                }
+                                else if (null != variableDefaultValue) // default the resolved value to the inline value if one was specified
+                                {
+                                    resolvedValue = variableDefaultValue;
+                                }
+                            }
+                        }
+
+                        if ("bind" == variableNamespace)
+                        {
+                            // can't resolve these yet, but keep track of where we find them so they can be resolved later with less effort
+                            delayedResolve = true;
+                        }
+                        else
+                        {
+                            // insert the resolved value if it was found or display an error
+                            if (null != resolvedValue)
+                            {
+                                sb.Remove(matches[i].Index, matches[i].Length);
+                                sb.Insert(matches[i].Index, resolvedValue);
+                            }
+                            else if ("loc" == variableNamespace && errorOnUnknown) // unresolved loc variable
+                            {
+                                Messaging.Instance.OnMessage(WixErrors.LocalizationVariableUnknown(sourceLineNumbers, variableId));
+                            }
+                            else if (!localizationOnly && "wix" == variableNamespace && errorOnUnknown) // unresolved wix variable
+                            {
+                                Messaging.Instance.OnMessage(WixErrors.WixVariableUnknown(sourceLineNumbers, variableId));
+                            }
+                        }
+                    }
+                }
+
+                value = sb.ToString();
+            }
+
+            return value;
+        }
+
+        /// <summary>
+        /// Resolve the delay variables in a value.
+        /// </summary>
+        /// <param name="sourceLineNumbers">The source line information for the value.</param>
+        /// <param name="value">The value to resolve.</param>
+        /// <param name="resolutionData"></param>
+        /// <returns>The resolved value.</returns>
+        [SuppressMessage("Microsoft.Usage", "CA1801:ReviewUnusedParameters", MessageId = "sourceLineNumbers")]
+        [SuppressMessage("Microsoft.Globalization", "CA1308:NormalizeStringsToUppercase", Justification = "This string is not round tripped, and not used for any security decisions")]
+        public static string ResolveDelayedVariables(SourceLineNumber sourceLineNumbers, string value, IDictionary<string, string> resolutionData)
+        {
+            MatchCollection matches = Common.WixVariableRegex.Matches(value);
+
+            if (0 < matches.Count)
+            {
+                StringBuilder sb = new StringBuilder(value);
+
+                // notice how this code walks backward through the list
+                // because it modifies the string as we go through it
+                for (int i = matches.Count - 1; 0 <= i; i--)
+                {
+                    string variableNamespace = matches[i].Groups["namespace"].Value;
+                    string variableId = matches[i].Groups["fullname"].Value;
+                    string variableDefaultValue = null;
+                    string variableScope = null;
+
+                    // get the default value if one was specified
+                    if (matches[i].Groups["value"].Success)
+                    {
+                        variableDefaultValue = matches[i].Groups["value"].Value;
+                    }
+
+                    // get the scope if one was specified
+                    if (matches[i].Groups["scope"].Success)
+                    {
+                        variableScope = matches[i].Groups["scope"].Value;
+                        if ("bind" == variableNamespace)
+                        {
+                            variableId = matches[i].Groups["name"].Value;
+                        }
+                    }
+
+                    // check for an escape sequence of !! indicating the match is not a variable expression
+                    if (0 < matches[i].Index && '!' == sb[matches[i].Index - 1])
+                    {
+                        sb.Remove(matches[i].Index - 1, 1);
+                    }
+                    else
+                    {
+                        string key = String.Format(CultureInfo.InvariantCulture, "{0}.{1}", variableId, variableScope).ToLower(CultureInfo.InvariantCulture);
+                        string resolvedValue = variableDefaultValue;
+
+                        if (resolutionData.ContainsKey(key))
+                        {
+                            resolvedValue = resolutionData[key];
+                        }
+
+                        if ("bind" == variableNamespace)
+                        {
+                            // insert the resolved value if it was found or display an error
+                            if (null != resolvedValue)
+                            {
+                                sb.Remove(matches[i].Index, matches[i].Length);
+                                sb.Insert(matches[i].Index, resolvedValue);
+                            }
+                            else
+                            {
+                                throw new WixException(WixErrors.UnresolvedBindReference(sourceLineNumbers, value));
+                            }
+                        }
+                    }
+                }
+
+                value = sb.ToString();
+            }
+
+            return value;
+        }
+    }
+}
diff --git a/src/candle/App.ico b/src/candle/App.ico
new file mode 100644
index 00000000..3a5525fd
--- /dev/null
+++ b/src/candle/App.ico
diff --git a/src/candle/AssemblyInfo.cs b/src/candle/AssemblyInfo.cs
new file mode 100644
index 00000000..7df55940
--- /dev/null
+++ b/src/candle/AssemblyInfo.cs
@@ -0,0 +1,11 @@
+// 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.
+
+using System;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+[assembly: AssemblyTitle("WiX Toolset Compiler")]
+[assembly: AssemblyDescription("Compiler")]
+[assembly: AssemblyCulture("")]
+[assembly: ComVisible(false)]
diff --git a/src/candle/CandleCommandLine.cs b/src/candle/CandleCommandLine.cs
new file mode 100644
index 00000000..81fdf7b2
--- /dev/null
+++ b/src/candle/CandleCommandLine.cs
@@ -0,0 +1,343 @@
+// 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.Tools
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.IO;
+    using WixToolset.Data;
+
+    /// <summary>
+    /// Parse command line for candle.
+    /// </summary>
+    public class CandleCommandLine
+    {
+        public CandleCommandLine()
+        {
+            this.Platform = Platform.X86;
+
+            this.ShowLogo = true;
+            this.Extensions = new List<string>();
+            this.Files = new List<CompileFile>();
+            this.IncludeSearchPaths = new List<string>();
+            this.PreprocessorVariables = new Dictionary<string, string>();
+        }
+
+        public Platform Platform { get; private set; }
+
+        public bool ShowLogo { get; private set; }
+
+        public bool ShowHelp { get; private set; }
+
+        public bool ShowPedanticMessages { get; private set; }
+
+        public string OutputFolder { get; private set; }
+
+        public string OutputFile { get; private set; }
+
+        public List<string> Extensions { get; private set; }
+
+        public List<CompileFile> Files { get; private set; }
+
+        public List<string> IncludeSearchPaths { get; private set; }
+
+        public string PreprocessFile { get; private set; }
+
+        public Dictionary<string, string> PreprocessorVariables { get; private set; }
+
+        /// <summary>
+        /// Parse the commandline arguments.
+        /// </summary>
+        /// <param name="args">Commandline arguments.</param>
+        public string[] Parse(string[] args)
+        {
+            List<string> unprocessed = new List<string>();
+
+            for (int i = 0; i < args.Length; ++i)
+            {
+                string arg = args[i];
+                if (String.IsNullOrEmpty(arg)) // skip blank arguments
+                {
+                    continue;
+                }
+
+                if (1 == arg.Length) // treat '-' and '@' as filenames when by themselves.
+                {
+                    unprocessed.Add(arg);
+                }
+                else if ('-' == arg[0] || '/' == arg[0])
+                {
+                    string parameter = arg.Substring(1);
+                    if ('d' == parameter[0])
+                    {
+                        if (1 >= parameter.Length || '=' == parameter[1])
+                        {
+                            Messaging.Instance.OnMessage(WixErrors.InvalidVariableDefinition(arg));
+                            break;
+                        }
+
+                        parameter = arg.Substring(2);
+
+                        string[] value = parameter.Split("=".ToCharArray(), 2);
+
+                        if (this.PreprocessorVariables.ContainsKey(value[0]))
+                        {
+                            Messaging.Instance.OnMessage(WixErrors.DuplicateVariableDefinition(value[0], (1 == value.Length) ? String.Empty : value[1], this.PreprocessorVariables[value[0]]));
+                            break;
+                        }
+
+                        if (1 == value.Length)
+                        {
+                            this.PreprocessorVariables.Add(value[0], String.Empty);
+                        }
+                        else
+                        {
+                            this.PreprocessorVariables.Add(value[0], value[1]);
+                        }
+                    }
+                    else if ('I' == parameter[0])
+                    {
+                        this.IncludeSearchPaths.Add(parameter.Substring(1));
+                    }
+                    else if ("ext" == parameter)
+                    {
+                        if (!CommandLine.IsValidArg(args, ++i))
+                        {
+                            Messaging.Instance.OnMessage(WixErrors.TypeSpecificationForExtensionRequired("-ext"));
+                            break;
+                        }
+                        else
+                        {
+                            this.Extensions.Add(args[i]);
+                        }
+                    }
+                    else if ("nologo" == parameter)
+                    {
+                        this.ShowLogo = false;
+                    }
+                    else if ("o" == parameter || "out" == parameter)
+                    {
+                        string path = CommandLine.GetFileOrDirectory(parameter, args, ++i);
+
+                        if (!String.IsNullOrEmpty(path))
+                        {
+                            if (path.EndsWith("\\", StringComparison.Ordinal) || path.EndsWith("/", StringComparison.Ordinal))
+                            {
+                                this.OutputFolder = path;
+                            }
+                            else
+                            {
+                                this.OutputFile = path;
+                            }
+                        }
+                        else
+                        {
+                            break;
+                        }
+                    }
+                    else if ("pedantic" == parameter)
+                    {
+                        this.ShowPedanticMessages = true;
+                    }
+                    else if ("arch" == parameter)
+                    {
+                        if (!CommandLine.IsValidArg(args, ++i))
+                        {
+                            Messaging.Instance.OnMessage(WixErrors.InvalidPlatformParameter(parameter, String.Empty));
+                            break;
+                        }
+
+                        if (String.Equals(args[i], "intel", StringComparison.OrdinalIgnoreCase) || String.Equals(args[i], "x86", StringComparison.OrdinalIgnoreCase))
+                        {
+                            this.Platform = Platform.X86;
+                        }
+                        else if (String.Equals(args[i], "x64", StringComparison.OrdinalIgnoreCase))
+                        {
+                            this.Platform = Platform.X64;
+                        }
+                        else if (String.Equals(args[i], "intel64", StringComparison.OrdinalIgnoreCase) || String.Equals(args[i], "ia64", StringComparison.OrdinalIgnoreCase))
+                        {
+                            this.Platform = Platform.IA64;
+                        }
+                        else if (String.Equals(args[i], "arm", StringComparison.OrdinalIgnoreCase))
+                        {
+                            this.Platform = Platform.ARM;
+                        }
+                        else
+                        {
+                            Messaging.Instance.OnMessage(WixErrors.InvalidPlatformParameter(parameter, args[i]));
+                        }
+                    }
+                    else if ('p' == parameter[0])
+                    {
+                        string file = parameter.Substring(1);
+                        this.PreprocessFile = String.IsNullOrEmpty(file) ? "con:" : file;
+                    }
+                    else if (parameter.StartsWith("sw", StringComparison.Ordinal))
+                    {
+                        string paramArg = parameter.Substring(2);
+                        try
+                        {
+                            if (0 == paramArg.Length)
+                            {
+                                Messaging.Instance.SuppressAllWarnings = true;
+                            }
+                            else
+                            {
+                                int suppressWarning = Convert.ToInt32(paramArg, CultureInfo.InvariantCulture.NumberFormat);
+                                if (0 >= suppressWarning)
+                                {
+                                    Messaging.Instance.OnMessage(WixErrors.IllegalSuppressWarningId(paramArg));
+                                }
+
+                                Messaging.Instance.SuppressWarningMessage(suppressWarning);
+                            }
+                        }
+                        catch (FormatException)
+                        {
+                            Messaging.Instance.OnMessage(WixErrors.IllegalSuppressWarningId(paramArg));
+                        }
+                        catch (OverflowException)
+                        {
+                            Messaging.Instance.OnMessage(WixErrors.IllegalSuppressWarningId(paramArg));
+                        }
+                    }
+                    else if (parameter.StartsWith("wx", StringComparison.Ordinal))
+                    {
+                        string paramArg = parameter.Substring(2);
+                        try
+                        {
+                            if (0 == paramArg.Length)
+                            {
+                                Messaging.Instance.WarningsAsError = true;
+                            }
+                            else
+                            {
+                                int elevateWarning = Convert.ToInt32(paramArg, CultureInfo.InvariantCulture.NumberFormat);
+                                if (0 >= elevateWarning)
+                                {
+                                    Messaging.Instance.OnMessage(WixErrors.IllegalWarningIdAsError(paramArg));
+                                }
+
+                                Messaging.Instance.ElevateWarningMessage(elevateWarning);
+                            }
+                        }
+                        catch (FormatException)
+                        {
+                            Messaging.Instance.OnMessage(WixErrors.IllegalWarningIdAsError(paramArg));
+                        }
+                        catch (OverflowException)
+                        {
+                            Messaging.Instance.OnMessage(WixErrors.IllegalWarningIdAsError(paramArg));
+                        }
+                    }
+                    else if ("v" == parameter)
+                    {
+                        Messaging.Instance.ShowVerboseMessages = true;
+                    }
+                    else if ("?" == parameter || "help" == parameter)
+                    {
+                        this.ShowHelp = true;
+                        break;
+                    }
+                    else
+                    {
+                        unprocessed.Add(arg);
+                    }
+                }
+                else if ('@' == arg[0])
+                {
+                    string[] parsedArgs = CommandLineResponseFile.Parse(arg.Substring(1));
+                    string[] unparsedArgs = this.Parse(parsedArgs);
+                    unprocessed.AddRange(unparsedArgs);
+                }
+                else
+                {
+                    unprocessed.Add(arg);
+                }
+            }
+
+            return unprocessed.ToArray();
+        }
+
+        public string[] ParsePostExtensions(string[] remaining)
+        {
+            List<string> unprocessed = new List<string>();
+            List<string> files = new List<string>();
+
+            for (int i = 0; i < remaining.Length; ++i)
+            {
+                string arg = remaining[i];
+                if (String.IsNullOrEmpty(arg)) // skip blank arguments
+                {
+                    continue;
+                }
+
+                if (1 < arg.Length && ('-' == arg[0] || '/' == arg[0]))
+                {
+                    unprocessed.Add(arg);
+                }
+                else
+                {
+                    files.AddRange(CommandLine.GetFiles(arg, "Source"));
+                }
+            }
+
+            if (0 == files.Count)
+            {
+                this.ShowHelp = true;
+            }
+            else
+            {
+                Dictionary<string, List<string>> sourcesForOutput = new Dictionary<string, List<string>>(StringComparer.OrdinalIgnoreCase);
+                foreach (string file in files)
+                {
+                    string sourceFileName = Path.GetFileName(file);
+
+                    CompileFile compileFile = new CompileFile();
+                    compileFile.SourcePath = Path.GetFullPath(file);
+
+                    if (null != this.OutputFile)
+                    {
+                        compileFile.OutputPath = this.OutputFile;
+                    }
+                    else if (null != this.OutputFolder)
+                    {
+                        compileFile.OutputPath = Path.Combine(this.OutputFolder, Path.ChangeExtension(sourceFileName, ".wixobj"));
+                    }
+                    else
+                    {
+                        compileFile.OutputPath = Path.ChangeExtension(sourceFileName, ".wixobj");
+                    }
+
+                    // Track which source files result in a given output file, to ensure we aren't
+                    // overwriting the output.
+                    List<string> sources;
+                    string targetPath = Path.GetFullPath(compileFile.OutputPath);
+                    if (!sourcesForOutput.TryGetValue(targetPath, out sources))
+                    {
+                        sources = new List<string>();
+                        sourcesForOutput.Add(targetPath, sources);
+                    }
+
+                    sources.Add(compileFile.SourcePath);
+
+                    this.Files.Add(compileFile);
+                }
+
+                // Show an error for every output file that had more than 1 source file.
+                foreach (KeyValuePair<string, List<string>> outputSources in sourcesForOutput)
+                {
+                    if (1 < outputSources.Value.Count)
+                    {
+                        string sourceFiles = String.Join(", ", outputSources.Value);
+                        Messaging.Instance.OnMessage(WixErrors.DuplicateSourcesForOutput(sourceFiles, outputSources.Key));
+                    }
+                }
+            }
+
+            return unprocessed.ToArray();
+        }
+    }
+}
diff --git a/src/candle/CandleStrings.Designer.cs b/src/candle/CandleStrings.Designer.cs
new file mode 100644
index 00000000..aaf7254e
--- /dev/null
+++ b/src/candle/CandleStrings.Designer.cs
@@ -0,0 +1,81 @@
+// 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.Tools {
+    using System;
+    
+    
+    /// <summary>
+    ///   A strongly-typed resource class, for looking up localized strings, etc.
+    /// </summary>
+    // This class was auto-generated by the StronglyTypedResourceBuilder
+    // class via a tool like ResGen or Visual Studio.
+    // To add or remove a member, edit your .ResX file then rerun ResGen
+    // with the /str option, or rebuild your VS project.
+    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
+    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
+    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
+    internal class CandleStrings {
+        
+        private static global::System.Resources.ResourceManager resourceMan;
+        
+        private static global::System.Globalization.CultureInfo resourceCulture;
+        
+        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
+        internal CandleStrings() {
+        }
+        
+        /// <summary>
+        ///   Returns the cached ResourceManager instance used by this class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Resources.ResourceManager ResourceManager {
+            get {
+                if (object.ReferenceEquals(resourceMan, null)) {
+                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("WixToolset.Tools.CandleStrings", typeof(CandleStrings).Assembly);
+                    resourceMan = temp;
+                }
+                return resourceMan;
+            }
+        }
+        
+        /// <summary>
+        ///   Overrides the current thread's CurrentUICulture property for all
+        ///   resource lookups using this strongly typed resource class.
+        /// </summary>
+        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
+        internal static global::System.Globalization.CultureInfo Culture {
+            get {
+                return resourceCulture;
+            }
+            set {
+                resourceCulture = value;
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to Cannot specify more than one source file with single output file.  Either specify an output directory for the -out argument by ending the argument with a &apos;\&apos; or remove the -out argument to have the source files compiled to the current directory..
+        /// </summary>
+        internal static string CannotSpecifyMoreThanOneSourceFileForSingleTargetFile {
+            get {
+                return ResourceManager.GetString("CannotSpecifyMoreThanOneSourceFileForSingleTargetFile", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to  usage:  candle.exe [-?] [-nologo] [-out outputFile] sourceFile [sourceFile ...] [@responseFile]
+        ///
+        ///   -arch      set architecture defaults for package, components, etc.
+        ///              values: x86, x64, or ia64 (default: x86)
+        ///   -d&lt;name&gt;[=&lt;value&gt;]  define a parameter for the preprocessor
+        ///   -ext &lt;extension&gt;  extension assembly or &quot;class, assembly&quot;
+        ///   -I&lt;dir&gt;    add to include search path
+        ///   -nologo    skip printing candle logo information
+        ///   -o[ut]     s [rest of string was truncated]&quot;;.
+        /// </summary>
+        internal static string HelpMessage {
+            get {
+                return ResourceManager.GetString("HelpMessage", resourceCulture);
+            }
+        }
+    }
+}
diff --git a/src/candle/CandleStrings.resx b/src/candle/CandleStrings.resx
new file mode 100644
index 00000000..d77788ca
--- /dev/null
+++ b/src/candle/CandleStrings.resx
@@ -0,0 +1,142 @@
+<?xml version="1.0" encoding="utf-8"?>
+<root>
+  <!-- 
+    Microsoft ResX Schema 
+    
+    Version 2.0
+    
+    The primary goals of this format is to allow a simple XML format 
+    that is mostly human readable. The generation and parsing of the 
+    various data types are done through the TypeConverter classes 
+    associated with the data types.
+    
+    Example:
+    
+    ... ado.net/XML headers & schema ...
+    <resheader name="resmimetype">text/microsoft-resx</resheader>
+    <resheader name="version">2.0</resheader>
+    <resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
+    <resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
+    <data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
+    <data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
+    <data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
+        <value>[base64 mime encoded serialized .NET Framework object]</value>
+    </data>
+    <data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
+        <value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
+        <comment>This is a comment</comment>
+    </data>
+                
+    There are any number of "resheader" rows that contain simple 
+    name/value pairs.
+    
+    Each data row contains a name, and value. The row also contains a 
+    type or mimetype. Type corresponds to a .NET class that support 
+    text/value conversion through the TypeConverter architecture. 
+    Classes that don't support this are serialized and stored with the 
+    mimetype set.
+    
+    The mimetype is used for serialized objects, and tells the 
+    ResXResourceReader how to depersist the object. This is currently not 
+    extensible. For a given mimetype the value must be set accordingly:
+    
+    Note - application/x-microsoft.net.object.binary.base64 is the format 
+    that the ResXResourceWriter will generate, however the reader can 
+    read any of the formats listed below.
+    
+    mimetype: application/x-microsoft.net.object.binary.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
+            : and then encoded with base64 encoding.
+    
+    mimetype: application/x-microsoft.net.object.soap.base64
+    value   : The object must be serialized with 
+            : System.Runtime.Serialization.Formatters.Soap.SoapFormatter
+            : and then encoded with base64 encoding.
+
+    mimetype: application/x-microsoft.net.object.bytearray.base64
+    value   : The object must be serialized into a byte array 
+            : using a System.ComponentModel.TypeConverter
+            : and then encoded with base64 encoding.
+    -->
+  <xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
+    <xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
+    <xsd:element name="root" msdata:IsDataSet="true">
+      <xsd:complexType>
+        <xsd:choice maxOccurs="unbounded">
+          <xsd:element name="metadata">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" />
+              </xsd:sequence>
+              <xsd:attribute name="name" use="required" type="xsd:string" />
+              <xsd:attribute name="type" type="xsd:string" />
+              <xsd:attribute name="mimetype" type="xsd:string" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="assembly">
+            <xsd:complexType>
+              <xsd:attribute name="alias" type="xsd:string" />
+              <xsd:attribute name="name" type="xsd:string" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="data">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+                <xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
+              <xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
+              <xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
+              <xsd:attribute ref="xml:space" />
+            </xsd:complexType>
+          </xsd:element>
+          <xsd:element name="resheader">
+            <xsd:complexType>
+              <xsd:sequence>
+                <xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
+              </xsd:sequence>
+              <xsd:attribute name="name" type="xsd:string" use="required" />
+            </xsd:complexType>
+          </xsd:element>
+        </xsd:choice>
+      </xsd:complexType>
+    </xsd:element>
+  </xsd:schema>
+  <resheader name="resmimetype">
+    <value>text/microsoft-resx</value>
+  </resheader>
+  <resheader name="version">
+    <value>2.0</value>
+  </resheader>
+  <resheader name="reader">
+    <value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <resheader name="writer">
+    <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  </resheader>
+  <data name="CannotSpecifyMoreThanOneSourceFileForSingleTargetFile" xml:space="preserve">
+    <value>Cannot specify more than one source file with single output file.  Either specify an output directory for the -out argument by ending the argument with a '\' or remove the -out argument to have the source files compiled to the current directory.</value>
+  </data>
+  <data name="HelpMessage" xml:space="preserve">
+    <value> usage:  candle.exe [-?] [-nologo] [-out outputFile] sourceFile [sourceFile ...] [@responseFile]
+
+   -arch      set architecture defaults for package, components, etc.
+              values: x86, x64, ia64 or arm (default: x86)
+   -d&lt;name&gt;[=&lt;value&gt;]  define a parameter for the preprocessor
+   -ext &lt;extension&gt;  extension assembly or "class, assembly"
+   -I&lt;dir&gt;    add to include search path
+   -nologo    skip printing candle logo information
+   -o[ut]     specify output file (default: write to current directory)
+   -p&lt;file&gt;   preprocess to a file (or stdout if no file supplied)
+   -pedantic  show pedantic messages
+   -sw[N]     suppress all warnings or a specific message ID
+              (example: -sw1009 -sw1103)
+   -v         verbose output
+   -wx[N]     treat all warnings or a specific message ID as an error
+              (example: -wx1009 -wx1103)
+   -? | -help this help information</value>
+  </data>
+</root>
\ No newline at end of file
diff --git a/src/candle/CompileFile.cs b/src/candle/CompileFile.cs
new file mode 100644
index 00000000..682acc21
--- /dev/null
+++ b/src/candle/CompileFile.cs
@@ -0,0 +1,20 @@
+// 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.Tools
+{
+    /// <summary>
+    /// Source code file to be compiled.
+    /// </summary>
+    public class CompileFile
+    {
+        /// <summary>
+        /// Path to the source code file.
+        /// </summary>
+        public string SourcePath { get; set; }
+
+        /// <summary>
+        /// Path to compile the output to.
+        /// </summary>
+        public string OutputPath { get; set; }
+    }
+}
diff --git a/src/candle/app.config b/src/candle/app.config
new file mode 100644
index 00000000..71c529fb
--- /dev/null
+++ b/src/candle/app.config
@@ -0,0 +1,9 @@
+<?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. -->
+
+
+<configuration>
+    <runtime>
+        <loadFromRemoteSources enabled="true"/>
+    </runtime>
+</configuration>
diff --git a/src/candle/candle.cs b/src/candle/candle.cs
new file mode 100644
index 00000000..f5c65cb1
--- /dev/null
+++ b/src/candle/candle.cs
@@ -0,0 +1,200 @@
+// 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.Tools
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Linq;
+    using System.Runtime.InteropServices;
+    using System.Xml.Linq;
+    using WixToolset.Data;
+    using WixToolset.Extensibility;
+
+    /// <summary>
+    /// The main entry point for candle.
+    /// </summary>
+    public sealed class Candle
+    {
+        private CandleCommandLine commandLine;
+
+        private IEnumerable<IPreprocessorExtension> preprocessorExtensions;
+        private IEnumerable<ICompilerExtension> compilerExtensions;
+        private IEnumerable<IExtensionData> extensionData;
+
+        /// <summary>
+        /// The main entry point for candle.
+        /// </summary>
+        /// <param name="args">Commandline arguments for the application.</param>
+        /// <returns>Returns the application error code.</returns>
+        [MTAThread]
+        public static int Main(string[] args)
+        {
+            AppCommon.PrepareConsoleForLocalization();
+            Messaging.Instance.InitializeAppName("CNDL", "candle.exe").Display += AppCommon.ConsoleDisplayMessage;
+
+            Candle candle = new Candle();
+            return candle.Execute(args);
+        }
+
+        private int Execute(string[] args)
+        {
+            try
+            {
+                string[] unparsed = this.ParseCommandLineAndLoadExtensions(args);
+
+                if (!Messaging.Instance.EncounteredError)
+                {
+                    if (this.commandLine.ShowLogo)
+                    {
+                        AppCommon.DisplayToolHeader();
+                    }
+
+                    if (this.commandLine.ShowHelp)
+                    {
+                        Console.WriteLine(CandleStrings.HelpMessage);
+                        AppCommon.DisplayToolFooter();
+                    }
+                    else
+                    {
+                        foreach (string arg in unparsed)
+                        {
+                            Messaging.Instance.OnMessage(WixWarnings.UnsupportedCommandLineArgument(arg));
+                        }
+
+                        this.Run();
+                    }
+                }
+            }
+            catch (WixException we)
+            {
+                Messaging.Instance.OnMessage(we.Error);
+            }
+            catch (Exception e)
+            {
+                Messaging.Instance.OnMessage(WixErrors.UnexpectedException(e.Message, e.GetType().ToString(), e.StackTrace));
+                if (e is NullReferenceException || e is SEHException)
+                {
+                    throw;
+                }
+            }
+
+            return Messaging.Instance.LastErrorNumber;
+        }
+
+        private string[] ParseCommandLineAndLoadExtensions(string[] args)
+        {
+            this.commandLine = new CandleCommandLine();
+            string[] unprocessed = commandLine.Parse(args);
+            if (Messaging.Instance.EncounteredError)
+            {
+                return unprocessed;
+            }
+
+            // Load extensions.
+            ExtensionManager extensionManager = new ExtensionManager();
+            foreach (string extension in this.commandLine.Extensions)
+            {
+                extensionManager.Load(extension);
+            }
+
+            // Preprocessor extension command line processing.
+            this.preprocessorExtensions = extensionManager.Create<IPreprocessorExtension>();
+            foreach (IExtensionCommandLine pce in this.preprocessorExtensions.Where(e => e is IExtensionCommandLine).Cast<IExtensionCommandLine>())
+            {
+                pce.MessageHandler = Messaging.Instance;
+                unprocessed = pce.ParseCommandLine(unprocessed);
+            }
+
+            // Compiler extension command line processing.
+            this.compilerExtensions = extensionManager.Create<ICompilerExtension>();
+            foreach (IExtensionCommandLine cce in this.compilerExtensions.Where(e => e is IExtensionCommandLine).Cast<IExtensionCommandLine>())
+            {
+                cce.MessageHandler = Messaging.Instance;
+                unprocessed = cce.ParseCommandLine(unprocessed);
+            }
+
+            // Extension data command line processing.
+            this.extensionData = extensionManager.Create<IExtensionData>();
+            foreach (IExtensionCommandLine dce in this.extensionData.Where(e => e is IExtensionCommandLine).Cast<IExtensionCommandLine>())
+            {
+                dce.MessageHandler = Messaging.Instance;
+                unprocessed = dce.ParseCommandLine(unprocessed);
+            }
+
+            return commandLine.ParsePostExtensions(unprocessed);
+        }
+
+        private void Run()
+        {
+            // Create the preprocessor and compiler
+            Preprocessor preprocessor = new Preprocessor();
+            preprocessor.CurrentPlatform = this.commandLine.Platform;
+
+            foreach (string includePath in this.commandLine.IncludeSearchPaths)
+            {
+                preprocessor.IncludeSearchPaths.Add(includePath);
+            }
+
+            foreach (IPreprocessorExtension pe in this.preprocessorExtensions)
+            {
+                preprocessor.AddExtension(pe);
+            }
+
+            Compiler compiler = new Compiler();
+            compiler.ShowPedanticMessages = this.commandLine.ShowPedanticMessages;
+            compiler.CurrentPlatform = this.commandLine.Platform;
+
+            foreach (IExtensionData ed in this.extensionData)
+            {
+                compiler.AddExtensionData(ed);
+            }
+
+            foreach (ICompilerExtension ce in this.compilerExtensions)
+            {
+                compiler.AddExtension(ce);
+            }
+
+            // Preprocess then compile each source file.
+            foreach (CompileFile file in this.commandLine.Files)
+            {
+                // print friendly message saying what file is being compiled
+                Console.WriteLine(file.SourcePath);
+
+                // preprocess the source
+                XDocument sourceDocument;
+                try
+                {
+                    if (!String.IsNullOrEmpty(this.commandLine.PreprocessFile))
+                    {
+                        preprocessor.PreprocessOut = this.commandLine.PreprocessFile.Equals("con:", StringComparison.OrdinalIgnoreCase) ? Console.Out : new StreamWriter(this.commandLine.PreprocessFile);
+                    }
+
+                    sourceDocument = preprocessor.Process(file.SourcePath, this.commandLine.PreprocessorVariables);
+                }
+                finally
+                {
+                    if (null != preprocessor.PreprocessOut && Console.Out != preprocessor.PreprocessOut)
+                    {
+                        preprocessor.PreprocessOut.Close();
+                    }
+                }
+
+                // If we're not actually going to compile anything, move on to the next file.
+                if (null == sourceDocument || !String.IsNullOrEmpty(this.commandLine.PreprocessFile))
+                {
+                    continue;
+                }
+
+                // and now we do what we came here to do...
+                Intermediate intermediate = compiler.Compile(sourceDocument);
+
+                // save the intermediate to disk if no errors were found for this source file
+                if (null != intermediate)
+                {
+                    intermediate.Save(file.OutputPath);
+                }
+            }
+        }
+    }
+}
diff --git a/src/candle/candle.csproj b/src/candle/candle.csproj
new file mode 100644
index 00000000..cea0cf62
--- /dev/null
+++ b/src/candle/candle.csproj
@@ -0,0 +1,62 @@
+<?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 DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
+  <PropertyGroup>
+    <ProjectGuid>{956401A5-3C04-4786-9611-B2AEC6207686}</ProjectGuid>
+    <AssemblyName>candle</AssemblyName>
+    <OutputType>Exe</OutputType>
+    <RootNamespace>WixToolset.Tools</RootNamespace>
+    <PlatformTarget>x86</PlatformTarget>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="AssemblyInfo.cs" />
+    <Compile Include="candle.cs" />
+    <Compile Include="CandleCommandLine.cs" />
+    <Compile Include="CompileFile.cs" />
+    <Compile Include="CandleStrings.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>CandleStrings.resx</DependentUpon>
+    </Compile>
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedNativeResource Include="candle.rc" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="app.config" />
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="CandleStrings.resx">
+      <SubType>Designer</SubType>
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>CandleStrings.Designer.cs</LastGenOutput>
+    </EmbeddedResource>
+  </ItemGroup>
+  <ItemGroup>
+    <Service Include="{B4F97281-0DBD-4835-9ED8-7DFB966E87FF}" />
+  </ItemGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Xml" />
+    <ProjectReference Include="..\..\libs\WixToolset.Data\WixToolset.Data.csproj">
+      <Project>{6a98499e-40ec-4335-9c31-96a2511d47c6}</Project>
+      <Name>WixToolset.Data</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\libs\WixToolset.Extensibility\WixToolset.Extensibility.csproj">
+      <Project>{eee88c2a-45a0-4e48-a40a-431a4ba458d8}</Project>
+      <Name>WixToolset.Extensibility</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\wconsole\wconsole.csproj">
+      <Project>{4B2BD779-59F7-4BF1-871C-A75952BCA749}</Project>
+      <Name>wconsole</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\wix\Wix.csproj">
+      <Project>{9E03A94C-C70E-45C6-A269-E737BBD8B319}</Project>
+      <Name>Wix</Name>
+    </ProjectReference>
+    <Reference Include="System.Xml.Linq" />
+  </ItemGroup>
+  <Import Project="$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildProjectDirectory), wix.proj))\tools\WixBuild.targets" />
+</Project>
diff --git a/src/candle/candle.exe.manifest b/src/candle/candle.exe.manifest
new file mode 100644
index 00000000..b05ab18b
--- /dev/null
+++ b/src/candle/candle.exe.manifest
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<!-- 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. -->
+
+
+<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0"> 
+ <assemblyIdentity name="WixToolset.Tools.Candle" version="2.0.0.0" processorArchitecture="x86" type="win32"/> 
+ <description>WiX Toolset Compiler</description> 
+ <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3"><security><requestedPrivileges><requestedExecutionLevel level="asInvoker" uiAccess="false"/></requestedPrivileges></security></trustInfo>
+</assembly>
diff --git a/src/candle/candle.rc b/src/candle/candle.rc
new file mode 100644
index 00000000..47864811
--- /dev/null
+++ b/src/candle/candle.rc
@@ -0,0 +1,10 @@
+// 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.
+
+#define VER_APP
+#define VER_ORIGINAL_FILENAME "candle.exe"
+#define VER_INTERNAL_NAME "candle"
+#define VER_FILE_DESCRIPTION "WiX Toolset Compiler"
+#include "wix.rc"
+
+#define MANIFEST_RESOURCE_ID 1
+MANIFEST_RESOURCE_ID RT_MANIFEST "candle.exe.manifest"
diff --git a/src/test/WixToolsetTest.BuildTasks/WixToolsetTest.BuildTasks.csproj b/src/test/WixToolsetTest.BuildTasks/WixToolsetTest.BuildTasks.csproj
new file mode 100644
index 00000000..46bbf4cf
--- /dev/null
+++ b/src/test/WixToolsetTest.BuildTasks/WixToolsetTest.BuildTasks.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>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+    <Description></Description>
+    <Title>WiX Toolset Tests for MSBuild Tasks</Title>
+  </PropertyGroup>
+
+  <PropertyGroup>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <!-- <ProjectReference Include="..\..\WixToolset.BuildTasks\WixToolset.BuildTasks.csproj" /> -->
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Nerdbank.GitVersioning" Version="2.0.41" PrivateAssets="all" />
+  </ItemGroup>
+</Project>
diff --git a/src/test/WixToolsetTest.BuildTasks/data/SimpleMsiPackage/MsiPackage/MsiPackage.wixproj b/src/test/WixToolsetTest.BuildTasks/data/SimpleMsiPackage/MsiPackage/MsiPackage.wixproj
new file mode 100644
index 00000000..cd956964
--- /dev/null
+++ b/src/test/WixToolsetTest.BuildTasks/data/SimpleMsiPackage/MsiPackage/MsiPackage.wixproj
@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="15.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
+    <ProductVersion>0.9</ProductVersion>
+    <ProjectGuid>7fb77005-c6e0-454f-8c2d-0a4a79c918ba</ProjectGuid>
+    <OutputName>MsiPackage</OutputName>
+    <OutputType>Package</OutputType>
+    <Name>MsiPackage</Name>
+    <RootNamespace>MsiPackage</RootNamespace>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <WixTargetsPath>..\..\..\..\..\..\build\Debug\net462\wix.targets</WixTargetsPath>
+    <WixTargetsPath>..\..\..\..\..\..\build\Debug\netstandard2.0\wix.targets</WixTargetsPath>
+    <WixTargetsPath>..\..\..\..\..\..\build\publish\wix.targets</WixTargetsPath>
+    <WixTargetsPath>..\..\..\..\..\..\build\Debug\net462\wix.targets</WixTargetsPath>
+  </PropertyGroup>
+
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
+    <PlatformName>$(Platform)</PlatformName>
+    <OutputPath>bin\$(Platform)\$(Configuration)\</OutputPath>
+    <DefineConstants>Debug</DefineConstants>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
+    <PlatformName>$(Platform)</PlatformName>
+    <OutputPath>bin\$(Platform)\$(Configuration)\</OutputPath>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x64' ">
+    <PlatformName>$(Platform)</PlatformName>
+    <OutputPath>bin\$(Platform)\$(Configuration)\</OutputPath>
+    <DefineConstants>Debug</DefineConstants>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x64' ">
+    <PlatformName>$(Platform)</PlatformName>
+    <OutputPath>bin\$(Platform)\$(Configuration)\</OutputPath>
+  </PropertyGroup>
+  <ItemGroup>
+    <Compile Include="Package.wxs" />
+    <Compile Include="PackageComponents.wxs" />
+  </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="Package.en-us.wxl" />
+  </ItemGroup>
+  <Import Project="$(WixTargetsPath)" Condition=" '$(WixTargetsPath)' != '' " />
+  <Import Project="$(MSBuildExtensionsPath32)\Microsoft\WiX\v3.x\wix.targets" Condition=" '$(WixTargetsPath)' == '' AND Exists('$(MSBuildExtensionsPath32)\Microsoft\WiX\v3.x\wix.targets') " />
+  <Target Name="EnsureWixToolsetInstalled" Condition=" '$(WixTargetsImported)' != 'true' ">
+    <Error Text="FG-WiX or WiX Toolset build tools (v3.11 or later) must be installed to build this project. To download FG-WiX, go to https://www.firegiant.com/downloads/. To download the WiX Toolset, go to http://wixtoolset.org/releases/." />
+  </Target>
+</Project>
\ No newline at end of file
diff --git a/src/test/WixToolsetTest.BuildTasks/data/SimpleMsiPackage/MsiPackage/Package.en-us.wxl b/src/test/WixToolsetTest.BuildTasks/data/SimpleMsiPackage/MsiPackage/Package.en-us.wxl
new file mode 100644
index 00000000..38c12ac1
--- /dev/null
+++ b/src/test/WixToolsetTest.BuildTasks/data/SimpleMsiPackage/MsiPackage/Package.en-us.wxl
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<!--
+This file contains the declaration of all the localizable strings.
+-->
+<WixLocalization xmlns="http://wixtoolset.org/schemas/v4/wxl" Culture="en-US">
+
+  <String Id="DowngradeError">A newer version of [ProductName] is already installed.</String>
+  <String Id="FeatureTitle">MsiPackage</String>
+
+</WixLocalization>
diff --git a/src/test/WixToolsetTest.BuildTasks/data/SimpleMsiPackage/MsiPackage/Package.wxs b/src/test/WixToolsetTest.BuildTasks/data/SimpleMsiPackage/MsiPackage/Package.wxs
new file mode 100644
index 00000000..d5a5a40d
--- /dev/null
+++ b/src/test/WixToolsetTest.BuildTasks/data/SimpleMsiPackage/MsiPackage/Package.wxs
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Wix xmlns="http://wixtoolset.org/schemas/v4/wxs">
+  <Product Id="*" Name="MsiPackage" Language="1033" Version="1.0.0.0" Manufacturer="Example Corporation" UpgradeCode="047730a5-30fe-4a62-a520-da9381b8226a">
+    <Package InstallerVersion="200" Compressed="yes" InstallScope="perMachine" />
+
+    <MajorUpgrade DowngradeErrorMessage="!(loc.DowngradeError)" />
+    <MediaTemplate />
+
+    <Feature Id="ProductFeature" Title="!(loc.FeatureTitle)">
+      <ComponentGroupRef Id="ProductComponents" />
+    </Feature>
+  </Product>
+
+  <Fragment>
+    <Directory Id="TARGETDIR" Name="SourceDir">
+      <Directory Id="ProgramFilesFolder">
+        <Directory Id="INSTALLFOLDER" Name="MsiPackage" />
+      </Directory>
+    </Directory>
+  </Fragment>
+</Wix>
diff --git a/src/test/WixToolsetTest.BuildTasks/data/SimpleMsiPackage/MsiPackage/PackageComponents.wxs b/src/test/WixToolsetTest.BuildTasks/data/SimpleMsiPackage/MsiPackage/PackageComponents.wxs
new file mode 100644
index 00000000..76a12a9a
--- /dev/null
+++ b/src/test/WixToolsetTest.BuildTasks/data/SimpleMsiPackage/MsiPackage/PackageComponents.wxs
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Wix xmlns="http://wixtoolset.org/schemas/v4/wxs">
+  <Fragment>
+    <ComponentGroup Id="ProductComponents" Directory="INSTALLFOLDER">
+       <Component>
+         <File Source="Package.wxs" />
+       </Component>
+    </ComponentGroup>
+  </Fragment>
+</Wix>
diff --git a/src/test/WixToolsetTest.BuildTasks/data/SimpleMsiPackage/MsiPackage/i.txt b/src/test/WixToolsetTest.BuildTasks/data/SimpleMsiPackage/MsiPackage/i.txt
new file mode 100644
index 00000000..53f23c98
--- /dev/null
+++ b/src/test/WixToolsetTest.BuildTasks/data/SimpleMsiPackage/MsiPackage/i.txt
diff --git a/src/test/WixToolsetTest.BuildTasks/data/SimpleMsiPackage/SimpleMsiPackage.sln b/src/test/WixToolsetTest.BuildTasks/data/SimpleMsiPackage/SimpleMsiPackage.sln
new file mode 100644
index 00000000..2c88704e
--- /dev/null
+++ b/src/test/WixToolsetTest.BuildTasks/data/SimpleMsiPackage/SimpleMsiPackage.sln
@@ -0,0 +1,31 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 15
+VisualStudioVersion = 15.0.26730.8
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{930C7802-8A8C-48F9-8165-68863BCCD9DD}") = "MsiPackage", "MsiPackage\MsiPackage.wixproj", "{7FB77005-C6E0-454F-8C2D-0A4A79C918BA}"
+EndProject
+Global
+        GlobalSection(SolutionConfigurationPlatforms) = preSolution
+                Debug|x64 = Debug|x64
+                Debug|x86 = Debug|x86
+                Release|x64 = Release|x64
+                Release|x86 = Release|x86
+        EndGlobalSection
+        GlobalSection(ProjectConfigurationPlatforms) = postSolution
+                {7FB77005-C6E0-454F-8C2D-0A4A79C918BA}.Debug|x64.ActiveCfg = Debug|x64
+                {7FB77005-C6E0-454F-8C2D-0A4A79C918BA}.Debug|x64.Build.0 = Debug|x64
+                {7FB77005-C6E0-454F-8C2D-0A4A79C918BA}.Debug|x86.ActiveCfg = Debug|x86
+                {7FB77005-C6E0-454F-8C2D-0A4A79C918BA}.Debug|x86.Build.0 = Debug|x86
+                {7FB77005-C6E0-454F-8C2D-0A4A79C918BA}.Release|x64.ActiveCfg = Release|x64
+                {7FB77005-C6E0-454F-8C2D-0A4A79C918BA}.Release|x64.Build.0 = Release|x64
+                {7FB77005-C6E0-454F-8C2D-0A4A79C918BA}.Release|x86.ActiveCfg = Release|x86
+                {7FB77005-C6E0-454F-8C2D-0A4A79C918BA}.Release|x86.Build.0 = Release|x86
+        EndGlobalSection
+        GlobalSection(SolutionProperties) = preSolution
+                HideSolutionNode = FALSE
+        EndGlobalSection
+        GlobalSection(ExtensibilityGlobals) = postSolution
+                SolutionGuid = {585B0599-4EB5-4AB6-BC66-819CC78B63D5}
+        EndGlobalSection
+EndGlobal
diff --git a/src/wix/Program.cs b/src/wix/Program.cs
new file mode 100644
index 00000000..3e4fa8f8
--- /dev/null
+++ b/src/wix/Program.cs
@@ -0,0 +1,499 @@
+// 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.Core
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using WixToolset.Data;
+
+    /// <summary>
+    /// The main entry point for candle.
+    /// </summary>
+    public sealed class Program
+    {
+        //private IEnumerable<IPreprocessorExtension> preprocessorExtensions;
+        //private IEnumerable<ICompilerExtension> compilerExtensions;
+        //private IEnumerable<IExtensionData> extensionData;
+
+        /// <summary>
+        /// The main entry point for candle.
+        /// </summary>
+        /// <param name="args">Commandline arguments for the application.</param>
+        /// <returns>Returns the application error code.</returns>
+        [MTAThread]
+        public static int Main(string[] args)
+        {
+            var command = CommandLine.ParseStandardCommandLine(args);
+
+            return command?.Execute() ?? 1;
+        }
+
+#if false
+        private static ICommand ParseCommandLine(string[] args)
+        {
+            var next = String.Empty;
+
+            var command = Commands.Unknown;
+            var showLogo = true;
+            var showVersion = false;
+            var outputFolder = String.Empty;
+            var outputFile = String.Empty;
+            var sourceFile = String.Empty;
+            var verbose = false;
+            var files = new List<string>();
+            var defines = new List<string>();
+            var includePaths = new List<string>();
+            var locFiles = new List<string>();
+            var suppressedWarnings = new List<int>();
+
+            var cli = CommandLine.Parse(args, (cmdline, arg) => Enum.TryParse(arg, true, out command), (cmdline, arg) =>
+            {
+                if (cmdline.IsSwitch(arg))
+                {
+                    var parameter = arg.TrimStart(new[] { '-', '/' });
+                    switch (parameter.ToLowerInvariant())
+                    {
+                        case "?":
+                        case "h":
+                        case "help":
+                            cmdline.ShowHelp = true;
+                            return true;
+
+                        case "d":
+                        case "define":
+                            cmdline.GetNextArgumentOrError(defines);
+                            return true;
+
+                        case "i":
+                        case "includepath":
+                            cmdline.GetNextArgumentOrError(includePaths);
+                            return true;
+
+                        case "loc":
+                            cmdline.GetNextArgumentAsFilePathOrError(locFiles, "localization files");
+                            return true;
+
+                        case "o":
+                        case "out":
+                            cmdline.GetNextArgumentOrError(ref outputFile);
+                            return true;
+
+                        case "nologo":
+                            showLogo = false;
+                            return true;
+
+                        case "v":
+                        case "verbose":
+                            verbose = true;
+                            return true;
+
+                        case "version":
+                        case "-version":
+                            showVersion = true;
+                            return true;
+                    }
+
+                    return false;
+                }
+                else
+                {
+                    files.AddRange(cmdline.GetFiles(arg, "source code"));
+                    return true;
+                }
+            });
+
+            if (showVersion)
+            {
+                return new VersionCommand();
+            }
+
+            if (showLogo)
+            {
+                AppCommon.DisplayToolHeader();
+            }
+
+            if (cli.ShowHelp)
+            {
+                return new HelpCommand(command);
+            }
+
+            switch (command)
+            {
+                case Commands.Build:
+                    {
+                        var sourceFiles = GatherSourceFiles(files, outputFolder);
+                        var variables = GatherPreprocessorVariables(defines);
+                        var extensions = cli.ExtensionManager;
+                        return new BuildCommand(sourceFiles, variables, locFiles, outputFile);
+                    }
+
+                case Commands.Compile:
+                    {
+                        var sourceFiles = GatherSourceFiles(files, outputFolder);
+                        var variables = GatherPreprocessorVariables(defines);
+                        return new CompileCommand(sourceFiles, variables);
+                    }
+            }
+
+            return null;
+        }
+
+        private static IEnumerable<SourceFile> GatherSourceFiles(IEnumerable<string> sourceFiles, string intermediateDirectory)
+        {
+            var files = new List<SourceFile>();
+
+            foreach (var item in sourceFiles)
+            {
+                var sourcePath = item;
+                var outputPath = Path.Combine(intermediateDirectory, Path.GetFileNameWithoutExtension(sourcePath) + ".wir");
+
+                files.Add(new SourceFile(sourcePath, outputPath));
+            }
+
+            return files;
+        }
+
+        private static IDictionary<string, string> GatherPreprocessorVariables(IEnumerable<string> defineConstants)
+        {
+            var variables = new Dictionary<string, string>();
+
+            foreach (var pair in defineConstants)
+            {
+                string[] value = pair.Split(new[] { '=' }, 2);
+
+                if (variables.ContainsKey(value[0]))
+                {
+                    Messaging.Instance.OnMessage(WixErrors.DuplicateVariableDefinition(value[0], (1 == value.Length) ? String.Empty : value[1], variables[value[0]]));
+                    continue;
+                }
+
+                variables.Add(value[0], (1 == value.Length) ? String.Empty : value[1]);
+            }
+
+            return variables;
+        }
+#endif
+
+#if false
+        private static ICommand ParseCommandLine2(string[] args)
+        {
+            var command = Commands.Unknown;
+
+            var nologo = false;
+            var outputFolder = String.Empty;
+            var outputFile = String.Empty;
+            var sourceFile = String.Empty;
+            var verbose = false;
+            IReadOnlyList<string> files = Array.Empty<string>();
+            IReadOnlyList<string> defines = Array.Empty<string>();
+            IReadOnlyList<string> includePaths = Array.Empty<string>();
+            IReadOnlyList<int> suppressedWarnings = Array.Empty<int>();
+            IReadOnlyList<string> locFiles = Array.Empty<string>();
+
+            ArgumentSyntax parsed = null;
+            try
+            {
+                parsed = ArgumentSyntax.Parse(args, syntax =>
+                {
+                    syntax.HandleErrors = false;
+                    //syntax.HandleHelp = false;
+                    syntax.ErrorOnUnexpectedArguments = false;
+
+                    syntax.DefineCommand("build", ref command, Commands.Build, "Build to final output");
+                    syntax.DefineOptionList("d|D|define", ref defines, "Preprocessor name value pairs");
+                    syntax.DefineOptionList("I|includePath", ref includePaths, "Include search paths");
+                    syntax.DefineOption("nologo", ref nologo, false, "Do not display logo");
+                    syntax.DefineOption("o|out", ref outputFile, "Output file");
+                    syntax.DefineOptionList("sw", ref suppressedWarnings, false, "Do not display logo");
+                    syntax.DefineOption("v|verbose", ref verbose, false, "Display verbose messages");
+                    syntax.DefineOptionList("l|loc", ref locFiles, "Localization files to load (.wxl)");
+                    syntax.DefineParameterList("files", ref files, "Source files to compile (.wxs)");
+
+                    syntax.DefineCommand("preprocess", ref command, Commands.Preprocess, "Preprocess a source files");
+                    syntax.DefineOptionList("d|D|define", ref defines, "Preprocessor name value pairs");
+                    syntax.DefineOptionList("I|includePath", ref includePaths, "Include search paths");
+                    syntax.DefineOption("nologo", ref nologo, false, "Do not display logo");
+                    syntax.DefineOption("o|out", ref outputFile, "Output file");
+                    syntax.DefineParameter("file", ref sourceFile, "File to process");
+
+                    syntax.DefineCommand("compile", ref command, Commands.Compile, "Compile source files");
+                    syntax.DefineOptionList("I|includePath", ref includePaths, "Include search paths");
+                    syntax.DefineOption("nologo", ref nologo, false, "Do not display logo");
+                    syntax.DefineOption("o|out", ref outputFolder, "Output folder");
+                    syntax.DefineOptionList("sw", ref suppressedWarnings, false, "Do not display logo");
+                    syntax.DefineOption("v|verbose", ref verbose, false, "Display verbose messages");
+                    syntax.DefineParameterList("files", ref files, "Source files to compile (.wxs)");
+
+                    syntax.DefineCommand("link", ref command, Commands.Link, "Link intermediate files");
+                    syntax.DefineOption("nologo", ref nologo, "Do not display logo");
+                    syntax.DefineOption("o|out", ref outputFile, "Output intermediate file (.wir)");
+                    syntax.DefineParameterList("files", ref files, "Intermediate files to link (.wir)");
+
+                    syntax.DefineCommand("bind", ref command, Commands.Bind, "Bind to final output");
+                    syntax.DefineOption("nologo", ref nologo, false, "Do not display logo");
+                    syntax.DefineOption("o|out", ref outputFile, "Output file");
+                    syntax.DefineParameterList("files", ref files, "Intermediate files to bind (.wir)");
+
+                    syntax.DefineCommand("version", ref command, Commands.Version, "Display version information");
+                });
+
+                if (IsHelpRequested(parsed))
+                {
+                    var width = Console.WindowWidth - 2;
+                    var text = parsed.GetHelpText(width < 20 ? 72 : width);
+                    Console.Error.WriteLine(text);
+
+                    return null;
+                }
+
+                //var u = result.GetArguments();
+
+                //var p = result.GetActiveParameters();
+
+                //var o = result.GetActiveOptions();
+
+                //var a = result.GetActiveArguments();
+
+                //var h = result.GetHelpText();
+
+                //foreach (var x in p)
+                //{
+                //    Console.WriteLine("{0}", x.Name);
+                //}
+
+                switch (command)
+                {
+                    case Commands.Build:
+                        {
+                            var sourceFiles = GatherSourceFiles(files, outputFolder);
+                            var variables = GatherPreprocessorVariables(defines);
+                            return new BuildCommand(sourceFiles, variables, locFiles, outputFile);
+                        }
+
+                    case Commands.Compile:
+                        {
+                            var sourceFiles = GatherSourceFiles(files, outputFolder);
+                            var variables = GatherPreprocessorVariables(defines);
+                            return new CompileCommand(sourceFiles, variables);
+                        }
+
+                    case Commands.Version:
+                        return new VersionCommand();
+                }
+
+                //var preprocessorVariables = this.GatherPreprocessorVariables();
+
+                //foreach (var sourceFile in sourceFiles)
+                //{
+                //    var document = preprocessor.Process(sourceFile.SourcePath, preprocessorVariables);
+
+                //    var intermediate = compiler.Compile(document);
+
+                //    intermediate.Save(sourceFile.OutputPath);
+                //}
+            }
+            //catch (ArgumentSyntaxException e)
+            //{
+            //    if (IsHelpRequested(parsed))
+            //    {
+            //        var width = Console.WindowWidth - 2;
+            //        var text = parsed.GetHelpText(width < 20 ? 72 : width);
+            //        Console.Error.WriteLine(text);
+            //    }
+            //    else
+            //    {
+            //        Console.Error.WriteLine(e.Message);
+            //    }
+            //}
+
+            return null;
+        }
+
+        //private static bool IsHelpRequested(ArgumentSyntax syntax)
+        //{
+        //    return syntax?.RemainingArguments
+        //                 .Any(a => String.Equals(a, @"-?", StringComparison.Ordinal) ||
+        //                           String.Equals(a, @"-h", StringComparison.Ordinal) ||
+        //                           String.Equals(a, @"--help", StringComparison.Ordinal)) ?? false;
+        //}
+#endif
+
+#if false
+        private int Execute(string[] args)
+        {
+            try
+            {
+                string[] unparsed = this.ParseCommandLineAndLoadExtensions(args);
+
+                if (!Messaging.Instance.EncounteredError)
+                {
+                    if (this.commandLine.ShowLogo)
+                    {
+                        AppCommon.DisplayToolHeader();
+                    }
+
+                    if (this.commandLine.ShowHelp)
+                    {
+                        Console.WriteLine(CandleStrings.HelpMessage);
+                        AppCommon.DisplayToolFooter();
+                    }
+                    else
+                    {
+                        foreach (string arg in unparsed)
+                        {
+                            Messaging.Instance.OnMessage(WixWarnings.UnsupportedCommandLineArgument(arg));
+                        }
+
+                        this.Run();
+                    }
+                }
+            }
+            catch (WixException we)
+            {
+                Messaging.Instance.OnMessage(we.Error);
+            }
+            catch (Exception e)
+            {
+                Messaging.Instance.OnMessage(WixErrors.UnexpectedException(e.Message, e.GetType().ToString(), e.StackTrace));
+                if (e is NullReferenceException || e is SEHException)
+                {
+                    throw;
+                }
+            }
+
+            return Messaging.Instance.LastErrorNumber;
+        }
+
+        private string[] ParseCommandLineAndLoadExtensions(string[] args)
+        {
+            this.commandLine = new CandleCommandLine();
+            string[] unprocessed = commandLine.Parse(args);
+            if (Messaging.Instance.EncounteredError)
+            {
+                return unprocessed;
+            }
+
+            // Load extensions.
+            ExtensionManager extensionManager = new ExtensionManager();
+            foreach (string extension in this.commandLine.Extensions)
+            {
+                extensionManager.Load(extension);
+            }
+
+            // Preprocessor extension command line processing.
+            this.preprocessorExtensions = extensionManager.Create<IPreprocessorExtension>();
+            foreach (IExtensionCommandLine pce in this.preprocessorExtensions.Where(e => e is IExtensionCommandLine).Cast<IExtensionCommandLine>())
+            {
+                pce.MessageHandler = Messaging.Instance;
+                unprocessed = pce.ParseCommandLine(unprocessed);
+            }
+
+            // Compiler extension command line processing.
+            this.compilerExtensions = extensionManager.Create<ICompilerExtension>();
+            foreach (IExtensionCommandLine cce in this.compilerExtensions.Where(e => e is IExtensionCommandLine).Cast<IExtensionCommandLine>())
+            {
+                cce.MessageHandler = Messaging.Instance;
+                unprocessed = cce.ParseCommandLine(unprocessed);
+            }
+
+            // Extension data command line processing.
+            this.extensionData = extensionManager.Create<IExtensionData>();
+            foreach (IExtensionCommandLine dce in this.extensionData.Where(e => e is IExtensionCommandLine).Cast<IExtensionCommandLine>())
+            {
+                dce.MessageHandler = Messaging.Instance;
+                unprocessed = dce.ParseCommandLine(unprocessed);
+            }
+
+            return commandLine.ParsePostExtensions(unprocessed);
+        }
+
+        private void Run()
+        {
+            // Create the preprocessor and compiler
+            Preprocessor preprocessor = new Preprocessor();
+            preprocessor.CurrentPlatform = this.commandLine.Platform;
+
+            foreach (string includePath in this.commandLine.IncludeSearchPaths)
+            {
+                preprocessor.IncludeSearchPaths.Add(includePath);
+            }
+
+            foreach (IPreprocessorExtension pe in this.preprocessorExtensions)
+            {
+                preprocessor.AddExtension(pe);
+            }
+
+            Compiler compiler = new Compiler();
+            compiler.ShowPedanticMessages = this.commandLine.ShowPedanticMessages;
+            compiler.CurrentPlatform = this.commandLine.Platform;
+
+            foreach (IExtensionData ed in this.extensionData)
+            {
+                compiler.AddExtensionData(ed);
+            }
+
+            foreach (ICompilerExtension ce in this.compilerExtensions)
+            {
+                compiler.AddExtension(ce);
+            }
+
+            // Preprocess then compile each source file.
+            foreach (CompileFile file in this.commandLine.Files)
+            {
+                // print friendly message saying what file is being compiled
+                Console.WriteLine(file.SourcePath);
+
+                // preprocess the source
+                XDocument sourceDocument;
+                try
+                {
+                    if (!String.IsNullOrEmpty(this.commandLine.PreprocessFile))
+                    {
+                        preprocessor.PreprocessOut = this.commandLine.PreprocessFile.Equals("con:", StringComparison.OrdinalIgnoreCase) ? Console.Out : new StreamWriter(this.commandLine.PreprocessFile);
+                    }
+
+                    sourceDocument = preprocessor.Process(file.SourcePath, this.commandLine.PreprocessorVariables);
+                }
+                finally
+                {
+                    if (null != preprocessor.PreprocessOut && Console.Out != preprocessor.PreprocessOut)
+                    {
+                        preprocessor.PreprocessOut.Close();
+                    }
+                }
+
+                // If we're not actually going to compile anything, move on to the next file.
+                if (null == sourceDocument || !String.IsNullOrEmpty(this.commandLine.PreprocessFile))
+                {
+                    continue;
+                }
+
+                // and now we do what we came here to do...
+                Intermediate intermediate = compiler.Compile(sourceDocument);
+
+                // save the intermediate to disk if no errors were found for this source file
+                if (null != intermediate)
+                {
+                    intermediate.Save(file.OutputPath);
+                }
+            }
+        }
+
+        public interface IOptions
+        {
+            IEnumerable<SourceFile> SourceFiles { get; }
+        }
+
+        public class CompilerOptions : IOptions
+        {
+            public CompilerOptions(IEnumerable<SourceFile> sources)
+            {
+                this.SourceFiles = sources;
+            }
+
+            public IEnumerable<SourceFile> SourceFiles { get; private set; }
+        }
+#endif
+    }
+}
diff --git a/src/wix/X_CommandLine.cs b/src/wix/X_CommandLine.cs
new file mode 100644
index 00000000..2c7ceb83
--- /dev/null
+++ b/src/wix/X_CommandLine.cs
@@ -0,0 +1,394 @@
+// 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.Core
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Linq;
+    using System.Text;
+    using System.Text.RegularExpressions;
+    using WixToolset.Extensibility;
+
+    internal class X_CommandLine
+    {
+        private X_CommandLine()
+        {
+        }
+
+        public static string ExpectedArgument { get; } = "expected argument";
+
+        public string ActiveCommand { get; private set; }
+
+        public string[] OriginalArguments { get; private set; }
+
+        public Queue<string> RemainingArguments { get; } = new Queue<string>();
+
+        public ExtensionManager ExtensionManager { get; } = new ExtensionManager();
+
+        public string ErrorArgument { get; set; }
+
+        public bool ShowHelp { get; set; }
+
+        public static X_CommandLine Parse(string commandLineString, Func<X_CommandLine, string, bool> parseArgument)
+        {
+            var arguments = X_CommandLine.ParseArgumentsToArray(commandLineString).ToArray();
+
+            return X_CommandLine.Parse(arguments, null, parseArgument);
+        }
+
+        public static X_CommandLine Parse(string[] commandLineArguments, Func<X_CommandLine, string, bool> parseArgument)
+        {
+            return X_CommandLine.Parse(commandLineArguments, null, parseArgument);
+        }
+
+        public static X_CommandLine Parse(string[] commandLineArguments, Func<X_CommandLine, string, bool> parseCommand, Func<X_CommandLine, string, bool> parseArgument)
+        {
+            var cmdline = new X_CommandLine();
+
+            cmdline.FlattenArgumentsWithResponseFilesIntoOriginalArguments(commandLineArguments);
+
+            cmdline.QueueArgumentsAndLoadExtensions(cmdline.OriginalArguments);
+
+            cmdline.ProcessRemainingArguments(parseArgument, parseCommand);
+
+            return cmdline;
+        }
+
+        /// <summary>
+        /// Get a set of files that possibly have a search pattern in the path (such as '*').
+        /// </summary>
+        /// <param name="searchPath">Search path to find files in.</param>
+        /// <param name="fileType">Type of file; typically "Source".</param>
+        /// <returns>An array of files matching the search path.</returns>
+        /// <remarks>
+        /// This method is written in this verbose way because it needs to support ".." in the path.
+        /// It needs the directory path isolated from the file name in order to use Directory.GetFiles
+        /// or DirectoryInfo.GetFiles.  The only way to get this directory path is manually since
+        /// Path.GetDirectoryName does not support ".." in the path.
+        /// </remarks>
+        /// <exception cref="WixFileNotFoundException">Throws WixFileNotFoundException if no file matching the pattern can be found.</exception>
+        public string[] GetFiles(string searchPath, string fileType)
+        {
+            if (null == searchPath)
+            {
+                throw new ArgumentNullException(nameof(searchPath));
+            }
+
+            // Convert alternate directory separators to the standard one.
+            string filePath = searchPath.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);
+            int lastSeparator = filePath.LastIndexOf(Path.DirectorySeparatorChar);
+            string[] files = null;
+
+            try
+            {
+                if (0 > lastSeparator)
+                {
+                    files = Directory.GetFiles(".", filePath);
+                }
+                else // found directory separator
+                {
+                    files = Directory.GetFiles(filePath.Substring(0, lastSeparator + 1), filePath.Substring(lastSeparator + 1));
+                }
+            }
+            catch (DirectoryNotFoundException)
+            {
+                // Don't let this function throw the DirectoryNotFoundException. This exception
+                // occurs for non-existant directories and invalid characters in the searchPattern.
+            }
+            catch (ArgumentException)
+            {
+                // Don't let this function throw the ArgumentException. This exception
+                // occurs in certain situations such as when passing a malformed UNC path.
+            }
+            catch (IOException)
+            {
+                throw new WixFileNotFoundException(searchPath, fileType);
+            }
+
+            if (null == files || 0 == files.Length)
+            {
+                throw new WixFileNotFoundException(searchPath, fileType);
+            }
+
+            return files;
+        }
+
+        /// <summary>
+        /// Validates that a valid switch (starts with "/" or "-"), and returns a bool indicating its validity
+        /// </summary>
+        /// <param name="args">The list of strings to check.</param>
+        /// <param name="index">The index (in args) of the commandline parameter to be validated.</param>
+        /// <returns>True if a valid switch exists there, false if not.</returns>
+        public bool IsSwitch(string arg)
+        {
+            return arg != null && ('/' == arg[0] || '-' == arg[0]);
+        }
+
+        /// <summary>
+        /// Validates that a valid switch (starts with "/" or "-"), and returns a bool indicating its validity
+        /// </summary>
+        /// <param name="args">The list of strings to check.</param>
+        /// <param name="index">The index (in args) of the commandline parameter to be validated.</param>
+        /// <returns>True if a valid switch exists there, false if not.</returns>
+        public bool IsSwitchAt(IEnumerable<string> args, int index)
+        {
+            var arg = args.ElementAtOrDefault(index);
+            return IsSwitch(arg);
+        }
+
+        public void GetNextArgumentOrError(ref string arg)
+        {
+            this.TryGetNextArgumentOrError(out arg);
+        }
+
+        public void GetNextArgumentOrError(IList<string> args)
+        {
+            if (this.TryGetNextArgumentOrError(out var arg))
+            {
+                args.Add(arg);
+            }
+        }
+
+        public void GetNextArgumentAsFilePathOrError(IList<string> args, string fileType)
+        {
+            if (this.TryGetNextArgumentOrError(out var arg))
+            {
+                foreach (var path in this.GetFiles(arg, fileType))
+                {
+                    args.Add(path);
+                }
+            }
+        }
+
+        public bool TryGetNextArgumentOrError(out string arg)
+        {
+            if (this.RemainingArguments.TryDequeue(out arg) && !this.IsSwitch(arg))
+            {
+                return true;
+            }
+
+            this.ErrorArgument = arg ?? X_CommandLine.ExpectedArgument;
+
+            return false;
+        }
+
+        private void FlattenArgumentsWithResponseFilesIntoOriginalArguments(string[] commandLineArguments)
+        {
+            List<string> args = new List<string>();
+
+            foreach (var arg in commandLineArguments)
+            {
+                if ('@' == arg[0])
+                {
+                    var responseFileArguments = X_CommandLine.ParseResponseFile(arg.Substring(1));
+                    args.AddRange(responseFileArguments);
+                }
+                else
+                {
+                    args.Add(arg);
+                }
+            }
+
+            this.OriginalArguments = args.ToArray();
+        }
+
+        private void QueueArgumentsAndLoadExtensions(string[] args)
+        {
+            for (var i = 0; i < args.Length; ++i)
+            {
+                var arg = args[i];
+
+                if ("-ext" == arg || "/ext" == arg)
+                {
+                    if (!this.IsSwitchAt(args, ++i))
+                    {
+                        this.ExtensionManager.Load(args[i]);
+                    }
+                    else
+                    {
+                        this.ErrorArgument = arg;
+                        break;
+                    }
+                }
+                else
+                {
+                    this.RemainingArguments.Enqueue(arg);
+                }
+            }
+        }
+
+        private void ProcessRemainingArguments(Func<X_CommandLine, string, bool> parseArgument, Func<X_CommandLine, string, bool> parseCommand)
+        {
+            var extensions = this.ExtensionManager.Create<IExtensionCommandLine>();
+
+            while (!this.ShowHelp &&
+                   String.IsNullOrEmpty(this.ErrorArgument) &&
+                   this.RemainingArguments.TryDequeue(out var arg))
+            {
+                if (String.IsNullOrWhiteSpace(arg)) // skip blank arguments.
+                {
+                    continue;
+                }
+
+                if ('-' == arg[0] || '/' == arg[0])
+                {
+                    if (!parseArgument(this, arg) &&
+                        !this.TryParseCommandLineArgumentWithExtension(arg, extensions))
+                    {
+                        this.ErrorArgument = arg;
+                    }
+                }
+                else if (String.IsNullOrEmpty(this.ActiveCommand) && parseCommand != null) // First non-switch must be the command, if commands are supported.
+                {
+                    if (parseCommand(this, arg))
+                    {
+                        this.ActiveCommand = arg;
+                    }
+                    else
+                    {
+                        this.ErrorArgument = arg;
+                    }
+                }
+                else if (!this.TryParseCommandLineArgumentWithExtension(arg, extensions) &&
+                         !parseArgument(this, arg))
+                {
+                    this.ErrorArgument = arg;
+                }
+            }
+        }
+
+        private bool TryParseCommandLineArgumentWithExtension(string arg, IEnumerable<IExtensionCommandLine> extensions)
+        {
+            foreach (var extension in extensions)
+            {
+                //if (extension.ParseArgument(this, arg))
+                //{
+                //    return true;
+                //}
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Parses a response file.
+        /// </summary>
+        /// <param name="responseFile">The file to parse.</param>
+        /// <returns>The array of arguments.</returns>
+        private static List<string> ParseResponseFile(string responseFile)
+        {
+            string arguments;
+
+            using (StreamReader reader = new StreamReader(responseFile))
+            {
+                arguments = reader.ReadToEnd();
+            }
+
+            return X_CommandLine.ParseArgumentsToArray(arguments);
+        }
+
+        /// <summary>
+        /// Parses an argument string into an argument array based on whitespace and quoting.
+        /// </summary>
+        /// <param name="arguments">Argument string.</param>
+        /// <returns>Argument array.</returns>
+        private static List<string> ParseArgumentsToArray(string arguments)
+        {
+            // Scan and parse the arguments string, dividing up the arguments based on whitespace.
+            // Unescaped quotes cause whitespace to be ignored, while the quotes themselves are removed.
+            // Quotes may begin and end inside arguments; they don't necessarily just surround whole arguments.
+            // Escaped quotes and escaped backslashes also need to be unescaped by this process.
+
+            // Collects the final list of arguments to be returned.
+            var argsList = new List<string>();
+
+            // True if we are inside an unescaped quote, meaning whitespace should be ignored.
+            var insideQuote = false;
+
+            // Index of the start of the current argument substring; either the start of the argument
+            // or the start of a quoted or unquoted sequence within it.
+            var partStart = 0;
+
+            // The current argument string being built; when completed it will be added to the list.
+            var arg = new StringBuilder();
+
+            for (int i = 0; i <= arguments.Length; i++)
+            {
+                if (i == arguments.Length || (Char.IsWhiteSpace(arguments[i]) && !insideQuote))
+                {
+                    // Reached a whitespace separator or the end of the string.
+
+                    // Finish building the current argument.
+                    arg.Append(arguments.Substring(partStart, i - partStart));
+
+                    // Skip over the whitespace character.
+                    partStart = i + 1;
+
+                    // Add the argument to the list if it's not empty.
+                    if (arg.Length > 0)
+                    {
+                        argsList.Add(X_CommandLine.ExpandEnvVars(arg.ToString()));
+                        arg.Length = 0;
+                    }
+                }
+                else if (i > partStart && arguments[i - 1] == '\\')
+                {
+                    // Check the character following an unprocessed backslash.
+                    // Unescape quotes, and backslashes followed by a quote.
+                    if (arguments[i] == '"' || (arguments[i] == '\\' && arguments.Length > i + 1 && arguments[i + 1] == '"'))
+                    {
+                        // Unescape the quote or backslash by skipping the preceeding backslash.
+                        arg.Append(arguments.Substring(partStart, i - 1 - partStart));
+                        arg.Append(arguments[i]);
+                        partStart = i + 1;
+                    }
+                }
+                else if (arguments[i] == '"')
+                {
+                    // Add the quoted or unquoted section to the argument string.
+                    arg.Append(arguments.Substring(partStart, i - partStart));
+
+                    // And skip over the quote character.
+                    partStart = i + 1;
+
+                    insideQuote = !insideQuote;
+                }
+            }
+
+            return argsList;
+        }
+
+        /// <summary>
+        /// Expand enxironment variables contained in the passed string
+        /// </summary>
+        /// <param name="arguments"></param>
+        /// <returns></returns>
+        private static string ExpandEnvVars(string arguments)
+        {
+            var id = Environment.GetEnvironmentVariables();
+
+            var regex = new Regex("(?<=\\%)(?:[\\w\\.]+)(?=\\%)");
+            MatchCollection matches = regex.Matches(arguments);
+
+            string value = String.Empty;
+            for (int i = 0; i <= (matches.Count - 1); i++)
+            {
+                try
+                {
+                    var key = matches[i].Value;
+                    regex = new Regex(String.Concat("(?i)(?:\\%)(?:", key, ")(?:\\%)"));
+                    value = id[key].ToString();
+                    arguments = regex.Replace(arguments, value);
+                }
+                catch (NullReferenceException)
+                {
+                    // Collapse unresolved environment variables.
+                    arguments = regex.Replace(arguments, value);
+                }
+            }
+
+            return arguments;
+        }
+    }
+}
diff --git a/src/wix/wix.csproj b/src/wix/wix.csproj
new file mode 100644
index 00000000..88017e3f
--- /dev/null
+++ b/src/wix/wix.csproj
@@ -0,0 +1,31 @@
+<?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>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+    <OutputType>Exe</OutputType>
+    <Description></Description>
+    <Title>WiX Toolset Compiler</Title>
+  </PropertyGroup>
+
+  <PropertyGroup>
+    <NoWarn>NU1701</NoWarn>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\WixToolset.Core\WixToolset.Core.csproj" />
+
+    <ProjectReference Include="$(WixToolsetRootFolder)\Data\src\WixToolset.Data\WixToolset.Data.csproj" Condition=" '$(Configuration)' == 'Debug' And Exists('$(WixToolsetRootFolder)\Data\src\WixToolset.Data\WixToolset.Data.csproj') " />
+    <PackageReference Include="WixToolset.Data" Version="4.0.*" Condition=" '$(Configuration)' == 'Release' Or !Exists('$(WixToolsetRootFolder)\Data\src\WixToolset.Data\WixToolset.Data.csproj') " />
+
+    <ProjectReference Include="$(WixToolsetRootFolder)\Extensibility\src\WixToolset.Extensibility\WixToolset.Extensibility.csproj" Condition=" '$(Configuration)' == 'Debug' And Exists('$(WixToolsetRootFolder)\Extensibility\src\WixToolset.Extensibility\WixToolset.Extensibility.csproj') " />
+    <PackageReference Include="WixToolset.Extensibility" Version="4.0.*" Condition=" '$(Configuration)' == 'Release' Or !Exists('$(WixToolsetRootFolder)\Extensibility\src\WixToolset.Extensibility\WixToolset.Extensibility.csproj') " />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Nerdbank.GitVersioning" Version="2.0.41" PrivateAssets="all" />
+    <PackageReference Include="WixBuildTools.MsgGen" Version="4.0.*" PrivateAssets="all" />
+    <PackageReference Include="WixBuildTools.XsdGen" Version="4.0.*" PrivateAssets="all" />
+  </ItemGroup>
+</Project>