Move Util.wixext into ext

36 files changed, 7908 insertions, 0 deletions

diff --git a/src/ext/Util/wixext/PerformanceCounterType.cs b/src/ext/Util/wixext/PerformanceCounterType.cs
new file mode 100644
index 00000000..1e06efd3
--- /dev/null
+++ b/src/ext/Util/wixext/PerformanceCounterType.cs
@@ -0,0 +1,192 @@
+// Captured from: C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETFramework\v4.6.1\System.dll
+
+namespace System.Diagnostics
+{
+    public enum PerformanceCounterType
+    {
+        //
+        // Summary:
+        //     An instantaneous counter that shows the most recently observed value in hexadecimal
+        //     format. Used, for example, to maintain a simple count of items or operations.
+        NumberOfItemsHEX32 = 0,
+        //
+        // Summary:
+        //     An instantaneous counter that shows the most recently observed value. Used, for
+        //     example, to maintain a simple count of a very large number of items or operations.
+        //     It is the same as NumberOfItemsHEX32 except that it uses larger fields to accommodate
+        //     larger values.
+        NumberOfItemsHEX64 = 256,
+        //
+        // Summary:
+        //     An instantaneous counter that shows the most recently observed value. Used, for
+        //     example, to maintain a simple count of items or operations.
+        NumberOfItems32 = 65536,
+        //
+        // Summary:
+        //     An instantaneous counter that shows the most recently observed value. Used, for
+        //     example, to maintain a simple count of a very large number of items or operations.
+        //     It is the same as NumberOfItems32 except that it uses larger fields to accommodate
+        //     larger values.
+        NumberOfItems64 = 65792,
+        //
+        // Summary:
+        //     A difference counter that shows the change in the measured attribute between
+        //     the two most recent sample intervals.
+        CounterDelta32 = 4195328,
+        //
+        // Summary:
+        //     A difference counter that shows the change in the measured attribute between
+        //     the two most recent sample intervals. It is the same as the CounterDelta32 counter
+        //     type except that is uses larger fields to accomodate larger values.
+        CounterDelta64 = 4195584,
+        //
+        // Summary:
+        //     An average counter that shows the average number of operations completed in one
+        //     second. When a counter of this type samples the data, each sampling interrupt
+        //     returns one or zero. The counter data is the number of ones that were sampled.
+        //     It measures time in units of ticks of the system performance timer.
+        SampleCounter = 4260864,
+        //
+        // Summary:
+        //     An average counter designed to monitor the average length of a queue to a resource
+        //     over time. It shows the difference between the queue lengths observed during
+        //     the last two sample intervals divided by the duration of the interval. This type
+        //     of counter is typically used to track the number of items that are queued or
+        //     waiting.
+        CountPerTimeInterval32 = 4523008,
+        //
+        // Summary:
+        //     An average counter that monitors the average length of a queue to a resource
+        //     over time. Counters of this type display the difference between the queue lengths
+        //     observed during the last two sample intervals, divided by the duration of the
+        //     interval. This counter type is the same as CountPerTimeInterval32 except that
+        //     it uses larger fields to accommodate larger values. This type of counter is typically
+        //     used to track a high-volume or very large number of items that are queued or
+        //     waiting.
+        CountPerTimeInterval64 = 4523264,
+        //
+        // Summary:
+        //     A difference counter that shows the average number of operations completed during
+        //     each second of the sample interval. Counters of this type measure time in ticks
+        //     of the system clock.
+        RateOfCountsPerSecond32 = 272696320,
+        //
+        // Summary:
+        //     A difference counter that shows the average number of operations completed during
+        //     each second of the sample interval. Counters of this type measure time in ticks
+        //     of the system clock. This counter type is the same as the RateOfCountsPerSecond32
+        //     type, but it uses larger fields to accommodate larger values to track a high-volume
+        //     number of items or operations per second, such as a byte-transmission rate.
+        RateOfCountsPerSecond64 = 272696576,
+        //
+        // Summary:
+        //     An instantaneous percentage counter that shows the ratio of a subset to its set
+        //     as a percentage. For example, it compares the number of bytes in use on a disk
+        //     to the total number of bytes on the disk. Counters of this type display the current
+        //     percentage only, not an average over time.
+        RawFraction = 537003008,
+        //
+        // Summary:
+        //     A percentage counter that shows the average time that a component is active as
+        //     a percentage of the total sample time.
+        CounterTimer = 541132032,
+        //
+        // Summary:
+        //     A percentage counter that shows the active time of a component as a percentage
+        //     of the total elapsed time of the sample interval. It measures time in units of
+        //     100 nanoseconds (ns). Counters of this type are designed to measure the activity
+        //     of one component at a time.
+        Timer100Ns = 542180608,
+        //
+        // Summary:
+        //     A percentage counter that shows the average ratio of hits to all operations during
+        //     the last two sample intervals.
+        SampleFraction = 549585920,
+        //
+        // Summary:
+        //     A percentage counter that displays the average percentage of active time observed
+        //     during sample interval. The value of these counters is calculated by monitoring
+        //     the percentage of time that the service was inactive and then subtracting that
+        //     value from 100 percent.
+        CounterTimerInverse = 557909248,
+        //
+        // Summary:
+        //     A percentage counter that shows the average percentage of active time observed
+        //     during the sample interval.
+        Timer100NsInverse = 558957824,
+        //
+        // Summary:
+        //     A percentage counter that displays the active time of one or more components
+        //     as a percentage of the total time of the sample interval. Because the numerator
+        //     records the active time of components operating simultaneously, the resulting
+        //     percentage can exceed 100 percent.
+        CounterMultiTimer = 574686464,
+        //
+        // Summary:
+        //     A percentage counter that shows the active time of one or more components as
+        //     a percentage of the total time of the sample interval. It measures time in 100
+        //     nanosecond (ns) units.
+        CounterMultiTimer100Ns = 575735040,
+        //
+        // Summary:
+        //     A percentage counter that shows the active time of one or more components as
+        //     a percentage of the total time of the sample interval. It derives the active
+        //     time by measuring the time that the components were not active and subtracting
+        //     the result from 100 percent by the number of objects monitored.
+        CounterMultiTimerInverse = 591463680,
+        //
+        // Summary:
+        //     A percentage counter that shows the active time of one or more components as
+        //     a percentage of the total time of the sample interval. Counters of this type
+        //     measure time in 100 nanosecond (ns) units. They derive the active time by measuring
+        //     the time that the components were not active and subtracting the result from
+        //     multiplying 100 percent by the number of objects monitored.
+        CounterMultiTimer100NsInverse = 592512256,
+        //
+        // Summary:
+        //     An average counter that measures the time it takes, on average, to complete a
+        //     process or operation. Counters of this type display a ratio of the total elapsed
+        //     time of the sample interval to the number of processes or operations completed
+        //     during that time. This counter type measures time in ticks of the system clock.
+        AverageTimer32 = 805438464,
+        //
+        // Summary:
+        //     A difference timer that shows the total time between when the component or process
+        //     started and the time when this value is calculated.
+        ElapsedTime = 807666944,
+        //
+        // Summary:
+        //     An average counter that shows how many items are processed, on average, during
+        //     an operation. Counters of this type display a ratio of the items processed to
+        //     the number of operations completed. The ratio is calculated by comparing the
+        //     number of items processed during the last interval to the number of operations
+        //     completed during the last interval.
+        AverageCount64 = 1073874176,
+        //
+        // Summary:
+        //     A base counter that stores the number of sampling interrupts taken and is used
+        //     as a denominator in the sampling fraction. The sampling fraction is the number
+        //     of samples that were 1 (or true) for a sample interrupt. Check that this value
+        //     is greater than zero before using it as the denominator in a calculation of SampleFraction.
+        SampleBase = 1073939457,
+        //
+        // Summary:
+        //     A base counter that is used in the calculation of time or count averages, such
+        //     as AverageTimer32 and AverageCount64. Stores the denominator for calculating
+        //     a counter to present "time per operation" or "count per operation".
+        AverageBase = 1073939458,
+        //
+        // Summary:
+        //     A base counter that stores the denominator of a counter that presents a general
+        //     arithmetic fraction. Check that this value is greater than zero before using
+        //     it as the denominator in a RawFraction value calculation.
+        RawBase = 1073939459,
+        //
+        // Summary:
+        //     A base counter that indicates the number of items sampled. It is used as the
+        //     denominator in the calculations to get an average among the items sampled when
+        //     taking timings of multiple, but similar items. Used with CounterMultiTimer, CounterMultiTimerInverse,
+        //     CounterMultiTimer100Ns, and CounterMultiTimer100NsInverse.
+        CounterMultiBase = 1107494144
+    }
+}
diff --git a/src/ext/Util/wixext/Symbols/EventManifestSymbol.cs b/src/ext/Util/wixext/Symbols/EventManifestSymbol.cs
new file mode 100644
index 00000000..ccd3c899
--- /dev/null
+++ b/src/ext/Util/wixext/Symbols/EventManifestSymbol.cs
@@ -0,0 +1,55 @@
+// 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.Util
+{
+    using WixToolset.Data;
+    using WixToolset.Util.Symbols;
+
+    public static partial class UtilSymbolDefinitions
+    {
+        public static readonly IntermediateSymbolDefinition EventManifest = new IntermediateSymbolDefinition(
+            UtilSymbolDefinitionType.EventManifest.ToString(),
+            new[]
+            {
+                new IntermediateFieldDefinition(nameof(EventManifestSymbolFields.ComponentRef), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(EventManifestSymbolFields.File), IntermediateFieldType.String),
+            },
+            typeof(EventManifestSymbol));
+    }
+}
+
+namespace WixToolset.Util.Symbols
+{
+    using WixToolset.Data;
+
+    public enum EventManifestSymbolFields
+    {
+        ComponentRef,
+        File,
+    }
+
+    public class EventManifestSymbol : IntermediateSymbol
+    {
+        public EventManifestSymbol() : base(UtilSymbolDefinitions.EventManifest, null, null)
+        {
+        }
+
+        public EventManifestSymbol(SourceLineNumber sourceLineNumber, Identifier id = null) : base(UtilSymbolDefinitions.EventManifest, sourceLineNumber, id)
+        {
+        }
+
+        public IntermediateField this[EventManifestSymbolFields index] => this.Fields[(int)index];
+
+        public string ComponentRef
+        {
+            get => this.Fields[(int)EventManifestSymbolFields.ComponentRef].AsString();
+            set => this.Set((int)EventManifestSymbolFields.ComponentRef, value);
+        }
+
+        public string File
+        {
+            get => this.Fields[(int)EventManifestSymbolFields.File].AsString();
+            set => this.Set((int)EventManifestSymbolFields.File, value);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/ext/Util/wixext/Symbols/FileSharePermissionsSymbol.cs b/src/ext/Util/wixext/Symbols/FileSharePermissionsSymbol.cs
new file mode 100644
index 00000000..3db92f22
--- /dev/null
+++ b/src/ext/Util/wixext/Symbols/FileSharePermissionsSymbol.cs
@@ -0,0 +1,63 @@
+// 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.Util
+{
+    using WixToolset.Data;
+    using WixToolset.Util.Symbols;
+
+    public static partial class UtilSymbolDefinitions
+    {
+        public static readonly IntermediateSymbolDefinition FileSharePermissions = new IntermediateSymbolDefinition(
+            UtilSymbolDefinitionType.FileSharePermissions.ToString(),
+            new[]
+            {
+                new IntermediateFieldDefinition(nameof(FileSharePermissionsSymbolFields.FileShareRef), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(FileSharePermissionsSymbolFields.UserRef), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(FileSharePermissionsSymbolFields.Permissions), IntermediateFieldType.Number),
+            },
+            typeof(FileSharePermissionsSymbol));
+    }
+}
+
+namespace WixToolset.Util.Symbols
+{
+    using WixToolset.Data;
+
+    public enum FileSharePermissionsSymbolFields
+    {
+        FileShareRef,
+        UserRef,
+        Permissions,
+    }
+
+    public class FileSharePermissionsSymbol : IntermediateSymbol
+    {
+        public FileSharePermissionsSymbol() : base(UtilSymbolDefinitions.FileSharePermissions, null, null)
+        {
+        }
+
+        public FileSharePermissionsSymbol(SourceLineNumber sourceLineNumber, Identifier id = null) : base(UtilSymbolDefinitions.FileSharePermissions, sourceLineNumber, id)
+        {
+        }
+
+        public IntermediateField this[FileSharePermissionsSymbolFields index] => this.Fields[(int)index];
+
+        public string FileShareRef
+        {
+            get => this.Fields[(int)FileSharePermissionsSymbolFields.FileShareRef].AsString();
+            set => this.Set((int)FileSharePermissionsSymbolFields.FileShareRef, value);
+        }
+
+        public string UserRef
+        {
+            get => this.Fields[(int)FileSharePermissionsSymbolFields.UserRef].AsString();
+            set => this.Set((int)FileSharePermissionsSymbolFields.UserRef, value);
+        }
+
+        public int Permissions
+        {
+            get => this.Fields[(int)FileSharePermissionsSymbolFields.Permissions].AsNumber();
+            set => this.Set((int)FileSharePermissionsSymbolFields.Permissions, value);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/ext/Util/wixext/Symbols/FileShareSymbol.cs b/src/ext/Util/wixext/Symbols/FileShareSymbol.cs
new file mode 100644
index 00000000..c956ff42
--- /dev/null
+++ b/src/ext/Util/wixext/Symbols/FileShareSymbol.cs
@@ -0,0 +1,71 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Util
+{
+    using WixToolset.Data;
+    using WixToolset.Util.Symbols;
+
+    public static partial class UtilSymbolDefinitions
+    {
+        public static readonly IntermediateSymbolDefinition FileShare = new IntermediateSymbolDefinition(
+            UtilSymbolDefinitionType.FileShare.ToString(),
+            new[]
+            {
+                new IntermediateFieldDefinition(nameof(FileShareSymbolFields.ShareName), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(FileShareSymbolFields.ComponentRef), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(FileShareSymbolFields.Description), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(FileShareSymbolFields.DirectoryRef), IntermediateFieldType.String),
+            },
+            typeof(FileShareSymbol));
+    }
+}
+
+namespace WixToolset.Util.Symbols
+{
+    using WixToolset.Data;
+
+    public enum FileShareSymbolFields
+    {
+        ShareName,
+        ComponentRef,
+        Description,
+        DirectoryRef,
+    }
+
+    public class FileShareSymbol : IntermediateSymbol
+    {
+        public FileShareSymbol() : base(UtilSymbolDefinitions.FileShare, null, null)
+        {
+        }
+
+        public FileShareSymbol(SourceLineNumber sourceLineNumber, Identifier id = null) : base(UtilSymbolDefinitions.FileShare, sourceLineNumber, id)
+        {
+        }
+
+        public IntermediateField this[FileShareSymbolFields index] => this.Fields[(int)index];
+
+        public string ShareName
+        {
+            get => this.Fields[(int)FileShareSymbolFields.ShareName].AsString();
+            set => this.Set((int)FileShareSymbolFields.ShareName, value);
+        }
+
+        public string ComponentRef
+        {
+            get => this.Fields[(int)FileShareSymbolFields.ComponentRef].AsString();
+            set => this.Set((int)FileShareSymbolFields.ComponentRef, value);
+        }
+
+        public string Description
+        {
+            get => this.Fields[(int)FileShareSymbolFields.Description].AsString();
+            set => this.Set((int)FileShareSymbolFields.Description, value);
+        }
+
+        public string DirectoryRef
+        {
+            get => this.Fields[(int)FileShareSymbolFields.DirectoryRef].AsString();
+            set => this.Set((int)FileShareSymbolFields.DirectoryRef, value);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/ext/Util/wixext/Symbols/GroupSymbol.cs b/src/ext/Util/wixext/Symbols/GroupSymbol.cs
new file mode 100644
index 00000000..b378db44
--- /dev/null
+++ b/src/ext/Util/wixext/Symbols/GroupSymbol.cs
@@ -0,0 +1,63 @@
+// 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.Util
+{
+    using WixToolset.Data;
+    using WixToolset.Util.Symbols;
+
+    public static partial class UtilSymbolDefinitions
+    {
+        public static readonly IntermediateSymbolDefinition Group = new IntermediateSymbolDefinition(
+            UtilSymbolDefinitionType.Group.ToString(),
+            new[]
+            {
+                new IntermediateFieldDefinition(nameof(GroupSymbolFields.ComponentRef), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(GroupSymbolFields.Name), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(GroupSymbolFields.Domain), IntermediateFieldType.String),
+            },
+            typeof(GroupSymbol));
+    }
+}
+
+namespace WixToolset.Util.Symbols
+{
+    using WixToolset.Data;
+
+    public enum GroupSymbolFields
+    {
+        ComponentRef,
+        Name,
+        Domain,
+    }
+
+    public class GroupSymbol : IntermediateSymbol
+    {
+        public GroupSymbol() : base(UtilSymbolDefinitions.Group, null, null)
+        {
+        }
+
+        public GroupSymbol(SourceLineNumber sourceLineNumber, Identifier id = null) : base(UtilSymbolDefinitions.Group, sourceLineNumber, id)
+        {
+        }
+
+        public IntermediateField this[GroupSymbolFields index] => this.Fields[(int)index];
+
+        public string ComponentRef
+        {
+            get => this.Fields[(int)GroupSymbolFields.ComponentRef].AsString();
+            set => this.Set((int)GroupSymbolFields.ComponentRef, value);
+        }
+
+        public string Name
+        {
+            get => this.Fields[(int)GroupSymbolFields.Name].AsString();
+            set => this.Set((int)GroupSymbolFields.Name, value);
+        }
+
+        public string Domain
+        {
+            get => this.Fields[(int)GroupSymbolFields.Domain].AsString();
+            set => this.Set((int)GroupSymbolFields.Domain, value);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/ext/Util/wixext/Symbols/PerfmonManifestSymbol.cs b/src/ext/Util/wixext/Symbols/PerfmonManifestSymbol.cs
new file mode 100644
index 00000000..03fef14e
--- /dev/null
+++ b/src/ext/Util/wixext/Symbols/PerfmonManifestSymbol.cs
@@ -0,0 +1,63 @@
+// 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.Util
+{
+    using WixToolset.Data;
+    using WixToolset.Util.Symbols;
+
+    public static partial class UtilSymbolDefinitions
+    {
+        public static readonly IntermediateSymbolDefinition PerfmonManifest = new IntermediateSymbolDefinition(
+            UtilSymbolDefinitionType.PerfmonManifest.ToString(),
+            new[]
+            {
+                new IntermediateFieldDefinition(nameof(PerfmonManifestSymbolFields.ComponentRef), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(PerfmonManifestSymbolFields.File), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(PerfmonManifestSymbolFields.ResourceFileDirectory), IntermediateFieldType.String),
+            },
+            typeof(PerfmonManifestSymbol));
+    }
+}
+
+namespace WixToolset.Util.Symbols
+{
+    using WixToolset.Data;
+
+    public enum PerfmonManifestSymbolFields
+    {
+        ComponentRef,
+        File,
+        ResourceFileDirectory,
+    }
+
+    public class PerfmonManifestSymbol : IntermediateSymbol
+    {
+        public PerfmonManifestSymbol() : base(UtilSymbolDefinitions.PerfmonManifest, null, null)
+        {
+        }
+
+        public PerfmonManifestSymbol(SourceLineNumber sourceLineNumber, Identifier id = null) : base(UtilSymbolDefinitions.PerfmonManifest, sourceLineNumber, id)
+        {
+        }
+
+        public IntermediateField this[PerfmonManifestSymbolFields index] => this.Fields[(int)index];
+
+        public string ComponentRef
+        {
+            get => this.Fields[(int)PerfmonManifestSymbolFields.ComponentRef].AsString();
+            set => this.Set((int)PerfmonManifestSymbolFields.ComponentRef, value);
+        }
+
+        public string File
+        {
+            get => this.Fields[(int)PerfmonManifestSymbolFields.File].AsString();
+            set => this.Set((int)PerfmonManifestSymbolFields.File, value);
+        }
+
+        public string ResourceFileDirectory
+        {
+            get => this.Fields[(int)PerfmonManifestSymbolFields.ResourceFileDirectory].AsString();
+            set => this.Set((int)PerfmonManifestSymbolFields.ResourceFileDirectory, value);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/ext/Util/wixext/Symbols/PerfmonSymbol.cs b/src/ext/Util/wixext/Symbols/PerfmonSymbol.cs
new file mode 100644
index 00000000..6784ebd1
--- /dev/null
+++ b/src/ext/Util/wixext/Symbols/PerfmonSymbol.cs
@@ -0,0 +1,63 @@
+// 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.Util
+{
+    using WixToolset.Data;
+    using WixToolset.Util.Symbols;
+
+    public static partial class UtilSymbolDefinitions
+    {
+        public static readonly IntermediateSymbolDefinition Perfmon = new IntermediateSymbolDefinition(
+            UtilSymbolDefinitionType.Perfmon.ToString(),
+            new[]
+            {
+                new IntermediateFieldDefinition(nameof(PerfmonSymbolFields.ComponentRef), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(PerfmonSymbolFields.File), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(PerfmonSymbolFields.Name), IntermediateFieldType.String),
+            },
+            typeof(PerfmonSymbol));
+    }
+}
+
+namespace WixToolset.Util.Symbols
+{
+    using WixToolset.Data;
+
+    public enum PerfmonSymbolFields
+    {
+        ComponentRef,
+        File,
+        Name,
+    }
+
+    public class PerfmonSymbol : IntermediateSymbol
+    {
+        public PerfmonSymbol() : base(UtilSymbolDefinitions.Perfmon, null, null)
+        {
+        }
+
+        public PerfmonSymbol(SourceLineNumber sourceLineNumber, Identifier id = null) : base(UtilSymbolDefinitions.Perfmon, sourceLineNumber, id)
+        {
+        }
+
+        public IntermediateField this[PerfmonSymbolFields index] => this.Fields[(int)index];
+
+        public string ComponentRef
+        {
+            get => this.Fields[(int)PerfmonSymbolFields.ComponentRef].AsString();
+            set => this.Set((int)PerfmonSymbolFields.ComponentRef, value);
+        }
+
+        public string File
+        {
+            get => this.Fields[(int)PerfmonSymbolFields.File].AsString();
+            set => this.Set((int)PerfmonSymbolFields.File, value);
+        }
+
+        public string Name
+        {
+            get => this.Fields[(int)PerfmonSymbolFields.Name].AsString();
+            set => this.Set((int)PerfmonSymbolFields.Name, value);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/ext/Util/wixext/Symbols/PerformanceCategorySymbol.cs b/src/ext/Util/wixext/Symbols/PerformanceCategorySymbol.cs
new file mode 100644
index 00000000..5ecf388c
--- /dev/null
+++ b/src/ext/Util/wixext/Symbols/PerformanceCategorySymbol.cs
@@ -0,0 +1,71 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Util
+{
+    using WixToolset.Data;
+    using WixToolset.Util.Symbols;
+
+    public static partial class UtilSymbolDefinitions
+    {
+        public static readonly IntermediateSymbolDefinition PerformanceCategory = new IntermediateSymbolDefinition(
+            UtilSymbolDefinitionType.PerformanceCategory.ToString(),
+            new[]
+            {
+                new IntermediateFieldDefinition(nameof(PerformanceCategorySymbolFields.ComponentRef), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(PerformanceCategorySymbolFields.Name), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(PerformanceCategorySymbolFields.IniData), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(PerformanceCategorySymbolFields.ConstantData), IntermediateFieldType.String),
+            },
+            typeof(PerformanceCategorySymbol));
+    }
+}
+
+namespace WixToolset.Util.Symbols
+{
+    using WixToolset.Data;
+
+    public enum PerformanceCategorySymbolFields
+    {
+        ComponentRef,
+        Name,
+        IniData,
+        ConstantData,
+    }
+
+    public class PerformanceCategorySymbol : IntermediateSymbol
+    {
+        public PerformanceCategorySymbol() : base(UtilSymbolDefinitions.PerformanceCategory, null, null)
+        {
+        }
+
+        public PerformanceCategorySymbol(SourceLineNumber sourceLineNumber, Identifier id = null) : base(UtilSymbolDefinitions.PerformanceCategory, sourceLineNumber, id)
+        {
+        }
+
+        public IntermediateField this[PerformanceCategorySymbolFields index] => this.Fields[(int)index];
+
+        public string ComponentRef
+        {
+            get => this.Fields[(int)PerformanceCategorySymbolFields.ComponentRef].AsString();
+            set => this.Set((int)PerformanceCategorySymbolFields.ComponentRef, value);
+        }
+
+        public string Name
+        {
+            get => this.Fields[(int)PerformanceCategorySymbolFields.Name].AsString();
+            set => this.Set((int)PerformanceCategorySymbolFields.Name, value);
+        }
+
+        public string IniData
+        {
+            get => this.Fields[(int)PerformanceCategorySymbolFields.IniData].AsString();
+            set => this.Set((int)PerformanceCategorySymbolFields.IniData, value);
+        }
+
+        public string ConstantData
+        {
+            get => this.Fields[(int)PerformanceCategorySymbolFields.ConstantData].AsString();
+            set => this.Set((int)PerformanceCategorySymbolFields.ConstantData, value);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/ext/Util/wixext/Symbols/SecureObjectsSymbol.cs b/src/ext/Util/wixext/Symbols/SecureObjectsSymbol.cs
new file mode 100644
index 00000000..25fc6dca
--- /dev/null
+++ b/src/ext/Util/wixext/Symbols/SecureObjectsSymbol.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.Util
+{
+    using WixToolset.Data;
+    using WixToolset.Util.Symbols;
+
+    public static partial class UtilSymbolDefinitions
+    {
+        public static readonly IntermediateSymbolDefinition SecureObjects = new IntermediateSymbolDefinition(
+            UtilSymbolDefinitionType.SecureObjects.ToString(),
+            new[]
+            {
+                new IntermediateFieldDefinition(nameof(SecureObjectsSymbolFields.SecureObject), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(SecureObjectsSymbolFields.Table), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(SecureObjectsSymbolFields.Domain), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(SecureObjectsSymbolFields.User), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(SecureObjectsSymbolFields.Attributes), IntermediateFieldType.Number),
+                new IntermediateFieldDefinition(nameof(SecureObjectsSymbolFields.Permission), IntermediateFieldType.Number),
+                new IntermediateFieldDefinition(nameof(SecureObjectsSymbolFields.ComponentRef), IntermediateFieldType.String),
+            },
+            typeof(SecureObjectsSymbol));
+    }
+}
+
+namespace WixToolset.Util.Symbols
+{
+    using System;
+    using WixToolset.Data;
+
+    public enum SecureObjectsSymbolFields
+    {
+        SecureObject,
+        Table,
+        Domain,
+        User,
+        Attributes,
+        Permission,
+        ComponentRef,
+    }
+
+    [Flags]
+    public enum WixPermissionExAttributes
+    {
+        None = 0x0,
+        Inheritable = 0x01
+    }
+
+    public class SecureObjectsSymbol : IntermediateSymbol
+    {
+        public SecureObjectsSymbol() : base(UtilSymbolDefinitions.SecureObjects, null, null)
+        {
+        }
+
+        public SecureObjectsSymbol(SourceLineNumber sourceLineNumber, Identifier id = null) : base(UtilSymbolDefinitions.SecureObjects, sourceLineNumber, id)
+        {
+        }
+
+        public IntermediateField this[SecureObjectsSymbolFields index] => this.Fields[(int)index];
+
+        public string SecureObject
+        {
+            get => this.Fields[(int)SecureObjectsSymbolFields.SecureObject].AsString();
+            set => this.Set((int)SecureObjectsSymbolFields.SecureObject, value);
+        }
+
+        public string Table
+        {
+            get => this.Fields[(int)SecureObjectsSymbolFields.Table].AsString();
+            set => this.Set((int)SecureObjectsSymbolFields.Table, value);
+        }
+
+        public string Domain
+        {
+            get => this.Fields[(int)SecureObjectsSymbolFields.Domain].AsString();
+            set => this.Set((int)SecureObjectsSymbolFields.Domain, value);
+        }
+
+        public string User
+        {
+            get => this.Fields[(int)SecureObjectsSymbolFields.User].AsString();
+            set => this.Set((int)SecureObjectsSymbolFields.User, value);
+        }
+
+        public WixPermissionExAttributes Attributes
+        {
+            get => (WixPermissionExAttributes)this.Fields[(int)SecureObjectsSymbolFields.Attributes].AsNumber();
+            set => this.Set((int)SecureObjectsSymbolFields.Attributes, (int)value);
+        }
+
+        public int? Permission
+        {
+            get => this.Fields[(int)SecureObjectsSymbolFields.Permission].AsNullableNumber();
+            set => this.Set((int)SecureObjectsSymbolFields.Permission, value);
+        }
+
+        public string ComponentRef
+        {
+            get => this.Fields[(int)SecureObjectsSymbolFields.ComponentRef].AsString();
+            set => this.Set((int)SecureObjectsSymbolFields.ComponentRef, value);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/ext/Util/wixext/Symbols/ServiceConfigSymbol.cs b/src/ext/Util/wixext/Symbols/ServiceConfigSymbol.cs
new file mode 100644
index 00000000..3a877f9b
--- /dev/null
+++ b/src/ext/Util/wixext/Symbols/ServiceConfigSymbol.cs
@@ -0,0 +1,119 @@
+// 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.Util
+{
+    using WixToolset.Data;
+    using WixToolset.Util.Symbols;
+
+    public static partial class UtilSymbolDefinitions
+    {
+        public static readonly IntermediateSymbolDefinition ServiceConfig = new IntermediateSymbolDefinition(
+            UtilSymbolDefinitionType.ServiceConfig.ToString(),
+            new[]
+            {
+                new IntermediateFieldDefinition(nameof(ServiceConfigSymbolFields.ServiceName), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(ServiceConfigSymbolFields.ComponentRef), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(ServiceConfigSymbolFields.NewService), IntermediateFieldType.Number),
+                new IntermediateFieldDefinition(nameof(ServiceConfigSymbolFields.FirstFailureActionType), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(ServiceConfigSymbolFields.SecondFailureActionType), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(ServiceConfigSymbolFields.ThirdFailureActionType), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(ServiceConfigSymbolFields.ResetPeriodInDays), IntermediateFieldType.Number),
+                new IntermediateFieldDefinition(nameof(ServiceConfigSymbolFields.RestartServiceDelayInSeconds), IntermediateFieldType.Number),
+                new IntermediateFieldDefinition(nameof(ServiceConfigSymbolFields.ProgramCommandLine), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(ServiceConfigSymbolFields.RebootMessage), IntermediateFieldType.String),
+            },
+            typeof(ServiceConfigSymbol));
+    }
+}
+
+namespace WixToolset.Util.Symbols
+{
+    using WixToolset.Data;
+
+    public enum ServiceConfigSymbolFields
+    {
+        ServiceName,
+        ComponentRef,
+        NewService,
+        FirstFailureActionType,
+        SecondFailureActionType,
+        ThirdFailureActionType,
+        ResetPeriodInDays,
+        RestartServiceDelayInSeconds,
+        ProgramCommandLine,
+        RebootMessage,
+    }
+
+    public class ServiceConfigSymbol : IntermediateSymbol
+    {
+        public ServiceConfigSymbol() : base(UtilSymbolDefinitions.ServiceConfig, null, null)
+        {
+        }
+
+        public ServiceConfigSymbol(SourceLineNumber sourceLineNumber, Identifier id = null) : base(UtilSymbolDefinitions.ServiceConfig, sourceLineNumber, id)
+        {
+        }
+
+        public IntermediateField this[ServiceConfigSymbolFields index] => this.Fields[(int)index];
+
+        public string ServiceName
+        {
+            get => this.Fields[(int)ServiceConfigSymbolFields.ServiceName].AsString();
+            set => this.Set((int)ServiceConfigSymbolFields.ServiceName, value);
+        }
+
+        public string ComponentRef
+        {
+            get => this.Fields[(int)ServiceConfigSymbolFields.ComponentRef].AsString();
+            set => this.Set((int)ServiceConfigSymbolFields.ComponentRef, value);
+        }
+
+        public int NewService
+        {
+            get => this.Fields[(int)ServiceConfigSymbolFields.NewService].AsNumber();
+            set => this.Set((int)ServiceConfigSymbolFields.NewService, value);
+        }
+
+        public string FirstFailureActionType
+        {
+            get => this.Fields[(int)ServiceConfigSymbolFields.FirstFailureActionType].AsString();
+            set => this.Set((int)ServiceConfigSymbolFields.FirstFailureActionType, value);
+        }
+
+        public string SecondFailureActionType
+        {
+            get => this.Fields[(int)ServiceConfigSymbolFields.SecondFailureActionType].AsString();
+            set => this.Set((int)ServiceConfigSymbolFields.SecondFailureActionType, value);
+        }
+
+        public string ThirdFailureActionType
+        {
+            get => this.Fields[(int)ServiceConfigSymbolFields.ThirdFailureActionType].AsString();
+            set => this.Set((int)ServiceConfigSymbolFields.ThirdFailureActionType, value);
+        }
+
+        public int? ResetPeriodInDays
+        {
+            get => this.Fields[(int)ServiceConfigSymbolFields.ResetPeriodInDays].AsNullableNumber();
+            set => this.Set((int)ServiceConfigSymbolFields.ResetPeriodInDays, value);
+        }
+
+        public int? RestartServiceDelayInSeconds
+        {
+            get => this.Fields[(int)ServiceConfigSymbolFields.RestartServiceDelayInSeconds].AsNullableNumber();
+            set => this.Set((int)ServiceConfigSymbolFields.RestartServiceDelayInSeconds, value);
+        }
+
+        public string ProgramCommandLine
+        {
+            get => this.Fields[(int)ServiceConfigSymbolFields.ProgramCommandLine].AsString();
+            set => this.Set((int)ServiceConfigSymbolFields.ProgramCommandLine, value);
+        }
+
+        public string RebootMessage
+        {
+            get => this.Fields[(int)ServiceConfigSymbolFields.RebootMessage].AsString();
+            set => this.Set((int)ServiceConfigSymbolFields.RebootMessage, value);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/ext/Util/wixext/Symbols/UserGroupSymbol.cs b/src/ext/Util/wixext/Symbols/UserGroupSymbol.cs
new file mode 100644
index 00000000..c8f3998e
--- /dev/null
+++ b/src/ext/Util/wixext/Symbols/UserGroupSymbol.cs
@@ -0,0 +1,55 @@
+// 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.Util
+{
+    using WixToolset.Data;
+    using WixToolset.Util.Symbols;
+
+    public static partial class UtilSymbolDefinitions
+    {
+        public static readonly IntermediateSymbolDefinition UserGroup = new IntermediateSymbolDefinition(
+            UtilSymbolDefinitionType.UserGroup.ToString(),
+            new[]
+            {
+                new IntermediateFieldDefinition(nameof(UserGroupSymbolFields.UserRef), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(UserGroupSymbolFields.GroupRef), IntermediateFieldType.String),
+            },
+            typeof(UserGroupSymbol));
+    }
+}
+
+namespace WixToolset.Util.Symbols
+{
+    using WixToolset.Data;
+
+    public enum UserGroupSymbolFields
+    {
+        UserRef,
+        GroupRef,
+    }
+
+    public class UserGroupSymbol : IntermediateSymbol
+    {
+        public UserGroupSymbol() : base(UtilSymbolDefinitions.UserGroup, null, null)
+        {
+        }
+
+        public UserGroupSymbol(SourceLineNumber sourceLineNumber, Identifier id = null) : base(UtilSymbolDefinitions.UserGroup, sourceLineNumber, id)
+        {
+        }
+
+        public IntermediateField this[UserGroupSymbolFields index] => this.Fields[(int)index];
+
+        public string UserRef
+        {
+            get => this.Fields[(int)UserGroupSymbolFields.UserRef].AsString();
+            set => this.Set((int)UserGroupSymbolFields.UserRef, value);
+        }
+
+        public string GroupRef
+        {
+            get => this.Fields[(int)UserGroupSymbolFields.GroupRef].AsString();
+            set => this.Set((int)UserGroupSymbolFields.GroupRef, value);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/ext/Util/wixext/Symbols/UserSymbol.cs b/src/ext/Util/wixext/Symbols/UserSymbol.cs
new file mode 100644
index 00000000..5f00064b
--- /dev/null
+++ b/src/ext/Util/wixext/Symbols/UserSymbol.cs
@@ -0,0 +1,79 @@
+// 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.Util
+{
+    using WixToolset.Data;
+    using WixToolset.Util.Symbols;
+
+    public static partial class UtilSymbolDefinitions
+    {
+        public static readonly IntermediateSymbolDefinition User = new IntermediateSymbolDefinition(
+            UtilSymbolDefinitionType.User.ToString(),
+            new[]
+            {
+                new IntermediateFieldDefinition(nameof(UserSymbolFields.ComponentRef), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(UserSymbolFields.Name), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(UserSymbolFields.Domain), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(UserSymbolFields.Password), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(UserSymbolFields.Attributes), IntermediateFieldType.Number),
+            },
+            typeof(UserSymbol));
+    }
+}
+
+namespace WixToolset.Util.Symbols
+{
+    using WixToolset.Data;
+
+    public enum UserSymbolFields
+    {
+        ComponentRef,
+        Name,
+        Domain,
+        Password,
+        Attributes,
+    }
+
+    public class UserSymbol : IntermediateSymbol
+    {
+        public UserSymbol() : base(UtilSymbolDefinitions.User, null, null)
+        {
+        }
+
+        public UserSymbol(SourceLineNumber sourceLineNumber, Identifier id = null) : base(UtilSymbolDefinitions.User, sourceLineNumber, id)
+        {
+        }
+
+        public IntermediateField this[UserSymbolFields index] => this.Fields[(int)index];
+
+        public string ComponentRef
+        {
+            get => this.Fields[(int)UserSymbolFields.ComponentRef].AsString();
+            set => this.Set((int)UserSymbolFields.ComponentRef, value);
+        }
+
+        public string Name
+        {
+            get => this.Fields[(int)UserSymbolFields.Name].AsString();
+            set => this.Set((int)UserSymbolFields.Name, value);
+        }
+
+        public string Domain
+        {
+            get => this.Fields[(int)UserSymbolFields.Domain].AsString();
+            set => this.Set((int)UserSymbolFields.Domain, value);
+        }
+
+        public string Password
+        {
+            get => this.Fields[(int)UserSymbolFields.Password].AsString();
+            set => this.Set((int)UserSymbolFields.Password, value);
+        }
+
+        public int Attributes
+        {
+            get => this.Fields[(int)UserSymbolFields.Attributes].AsNumber();
+            set => this.Set((int)UserSymbolFields.Attributes, value);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/ext/Util/wixext/Symbols/UtilSymbolDefinitions.cs b/src/ext/Util/wixext/Symbols/UtilSymbolDefinitions.cs
new file mode 100644
index 00000000..72091c3b
--- /dev/null
+++ b/src/ext/Util/wixext/Symbols/UtilSymbolDefinitions.cs
@@ -0,0 +1,125 @@
+// 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.Util
+{
+    using System;
+    using WixToolset.Data;
+    using WixToolset.Data.Burn;
+
+    public enum UtilSymbolDefinitionType
+    {
+        EventManifest,
+        FileShare,
+        FileSharePermissions,
+        Group,
+        Perfmon,
+        PerfmonManifest,
+        PerformanceCategory,
+        SecureObjects,
+        ServiceConfig,
+        User,
+        UserGroup,
+        WixCloseApplication,
+        WixFormatFiles,
+        WixInternetShortcut,
+        WixRemoveFolderEx,
+        WixRemoveRegistryKeyEx,
+        WixRestartResource,
+        WixTouchFile,
+        WixWindowsFeatureSearch,
+        XmlConfig,
+        XmlFile,
+    }
+
+    public static partial class UtilSymbolDefinitions
+    {
+        public static readonly Version Version = new Version("4.0.0");
+
+        public static IntermediateSymbolDefinition ByName(string name)
+        {
+            if (!Enum.TryParse(name, out UtilSymbolDefinitionType type))
+            {
+                return null;
+            }
+
+            return ByType(type);
+        }
+
+        public static IntermediateSymbolDefinition ByType(UtilSymbolDefinitionType type)
+        {
+            switch (type)
+            {
+                case UtilSymbolDefinitionType.EventManifest:
+                    return UtilSymbolDefinitions.EventManifest;
+
+                case UtilSymbolDefinitionType.FileShare:
+                    return UtilSymbolDefinitions.FileShare;
+
+                case UtilSymbolDefinitionType.FileSharePermissions:
+                    return UtilSymbolDefinitions.FileSharePermissions;
+
+                case UtilSymbolDefinitionType.Group:
+                    return UtilSymbolDefinitions.Group;
+
+                case UtilSymbolDefinitionType.Perfmon:
+                    return UtilSymbolDefinitions.Perfmon;
+
+                case UtilSymbolDefinitionType.PerfmonManifest:
+                    return UtilSymbolDefinitions.PerfmonManifest;
+
+                case UtilSymbolDefinitionType.PerformanceCategory:
+                    return UtilSymbolDefinitions.PerformanceCategory;
+
+                case UtilSymbolDefinitionType.SecureObjects:
+                    return UtilSymbolDefinitions.SecureObjects;
+
+                case UtilSymbolDefinitionType.ServiceConfig:
+                    return UtilSymbolDefinitions.ServiceConfig;
+
+                case UtilSymbolDefinitionType.User:
+                    return UtilSymbolDefinitions.User;
+
+                case UtilSymbolDefinitionType.UserGroup:
+                    return UtilSymbolDefinitions.UserGroup;
+
+                case UtilSymbolDefinitionType.WixCloseApplication:
+                    return UtilSymbolDefinitions.WixCloseApplication;
+
+                case UtilSymbolDefinitionType.WixFormatFiles:
+                    return UtilSymbolDefinitions.WixFormatFiles;
+
+                case UtilSymbolDefinitionType.WixInternetShortcut:
+                    return UtilSymbolDefinitions.WixInternetShortcut;
+
+                case UtilSymbolDefinitionType.WixRemoveFolderEx:
+                    return UtilSymbolDefinitions.WixRemoveFolderEx;
+
+                case UtilSymbolDefinitionType.WixRemoveRegistryKeyEx:
+                    return UtilSymbolDefinitions.WixRemoveRegistryKeyEx;
+                    
+                case UtilSymbolDefinitionType.WixRestartResource:
+                    return UtilSymbolDefinitions.WixRestartResource;
+
+                case UtilSymbolDefinitionType.WixTouchFile:
+                    return UtilSymbolDefinitions.WixTouchFile;
+
+                case UtilSymbolDefinitionType.WixWindowsFeatureSearch:
+                    return UtilSymbolDefinitions.WixWindowsFeatureSearch;
+
+                case UtilSymbolDefinitionType.XmlConfig:
+                    return UtilSymbolDefinitions.XmlConfig;
+
+                case UtilSymbolDefinitionType.XmlFile:
+                    return UtilSymbolDefinitions.XmlFile;
+
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(type));
+            }
+        }
+
+        static UtilSymbolDefinitions()
+        {
+            WixWindowsFeatureSearch.AddTag(BurnConstants.BundleExtensionSearchSymbolDefinitionTag);
+        }
+    }
+}
diff --git a/src/ext/Util/wixext/Symbols/WixCloseApplicationSymbol.cs b/src/ext/Util/wixext/Symbols/WixCloseApplicationSymbol.cs
new file mode 100644
index 00000000..0738e3e4
--- /dev/null
+++ b/src/ext/Util/wixext/Symbols/WixCloseApplicationSymbol.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.Util
+{
+    using WixToolset.Data;
+    using WixToolset.Util.Symbols;
+
+    public static partial class UtilSymbolDefinitions
+    {
+        public static readonly IntermediateSymbolDefinition WixCloseApplication = new IntermediateSymbolDefinition(
+            UtilSymbolDefinitionType.WixCloseApplication.ToString(),
+            new[]
+            {
+                new IntermediateFieldDefinition(nameof(WixCloseApplicationSymbolFields.Target), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(WixCloseApplicationSymbolFields.Description), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(WixCloseApplicationSymbolFields.Condition), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(WixCloseApplicationSymbolFields.Attributes), IntermediateFieldType.Number),
+                new IntermediateFieldDefinition(nameof(WixCloseApplicationSymbolFields.Sequence), IntermediateFieldType.Number),
+                new IntermediateFieldDefinition(nameof(WixCloseApplicationSymbolFields.Property), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(WixCloseApplicationSymbolFields.TerminateExitCode), IntermediateFieldType.Number),
+                new IntermediateFieldDefinition(nameof(WixCloseApplicationSymbolFields.Timeout), IntermediateFieldType.Number),
+            },
+            typeof(WixCloseApplicationSymbol));
+    }
+}
+
+namespace WixToolset.Util.Symbols
+{
+    using WixToolset.Data;
+
+    public enum WixCloseApplicationSymbolFields
+    {
+        Target,
+        Description,
+        Condition,
+        Attributes,
+        Sequence,
+        Property,
+        TerminateExitCode,
+        Timeout,
+    }
+
+    public class WixCloseApplicationSymbol : IntermediateSymbol
+    {
+        public WixCloseApplicationSymbol() : base(UtilSymbolDefinitions.WixCloseApplication, null, null)
+        {
+        }
+
+        public WixCloseApplicationSymbol(SourceLineNumber sourceLineNumber, Identifier id = null) : base(UtilSymbolDefinitions.WixCloseApplication, sourceLineNumber, id)
+        {
+        }
+
+        public IntermediateField this[WixCloseApplicationSymbolFields index] => this.Fields[(int)index];
+
+        public string Target
+        {
+            get => this.Fields[(int)WixCloseApplicationSymbolFields.Target].AsString();
+            set => this.Set((int)WixCloseApplicationSymbolFields.Target, value);
+        }
+
+        public string Description
+        {
+            get => this.Fields[(int)WixCloseApplicationSymbolFields.Description].AsString();
+            set => this.Set((int)WixCloseApplicationSymbolFields.Description, value);
+        }
+
+        public string Condition
+        {
+            get => this.Fields[(int)WixCloseApplicationSymbolFields.Condition].AsString();
+            set => this.Set((int)WixCloseApplicationSymbolFields.Condition, value);
+        }
+
+        public int Attributes
+        {
+            get => this.Fields[(int)WixCloseApplicationSymbolFields.Attributes].AsNumber();
+            set => this.Set((int)WixCloseApplicationSymbolFields.Attributes, value);
+        }
+
+        public int? Sequence
+        {
+            get => this.Fields[(int)WixCloseApplicationSymbolFields.Sequence].AsNullableNumber();
+            set => this.Set((int)WixCloseApplicationSymbolFields.Sequence, value);
+        }
+
+        public string Property
+        {
+            get => this.Fields[(int)WixCloseApplicationSymbolFields.Property].AsString();
+            set => this.Set((int)WixCloseApplicationSymbolFields.Property, value);
+        }
+
+        public int? TerminateExitCode
+        {
+            get => this.Fields[(int)WixCloseApplicationSymbolFields.TerminateExitCode].AsNullableNumber();
+            set => this.Set((int)WixCloseApplicationSymbolFields.TerminateExitCode, value);
+        }
+
+        public int? Timeout
+        {
+            get => this.Fields[(int)WixCloseApplicationSymbolFields.Timeout].AsNullableNumber();
+            set => this.Set((int)WixCloseApplicationSymbolFields.Timeout, value);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/ext/Util/wixext/Symbols/WixFormatFilesSymbol.cs b/src/ext/Util/wixext/Symbols/WixFormatFilesSymbol.cs
new file mode 100644
index 00000000..38a9b8ff
--- /dev/null
+++ b/src/ext/Util/wixext/Symbols/WixFormatFilesSymbol.cs
@@ -0,0 +1,55 @@
+// 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.Util
+{
+    using WixToolset.Data;
+    using WixToolset.Util.Symbols;
+
+    public static partial class UtilSymbolDefinitions
+    {
+        public static readonly IntermediateSymbolDefinition WixFormatFiles = new IntermediateSymbolDefinition(
+            UtilSymbolDefinitionType.WixFormatFiles.ToString(),
+            new[]
+            {
+                new IntermediateFieldDefinition(nameof(WixFormatFilesSymbolFields.BinaryRef), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(WixFormatFilesSymbolFields.FileRef), IntermediateFieldType.String),
+            },
+            typeof(WixFormatFilesSymbol));
+    }
+}
+
+namespace WixToolset.Util.Symbols
+{
+    using WixToolset.Data;
+
+    public enum WixFormatFilesSymbolFields
+    {
+        BinaryRef,
+        FileRef,
+    }
+
+    public class WixFormatFilesSymbol : IntermediateSymbol
+    {
+        public WixFormatFilesSymbol() : base(UtilSymbolDefinitions.WixFormatFiles, null, null)
+        {
+        }
+
+        public WixFormatFilesSymbol(SourceLineNumber sourceLineNumber, Identifier id = null) : base(UtilSymbolDefinitions.WixFormatFiles, sourceLineNumber, id)
+        {
+        }
+
+        public IntermediateField this[WixFormatFilesSymbolFields index] => this.Fields[(int)index];
+
+        public string BinaryRef
+        {
+            get => this.Fields[(int)WixFormatFilesSymbolFields.BinaryRef].AsString();
+            set => this.Set((int)WixFormatFilesSymbolFields.BinaryRef, value);
+        }
+
+        public string FileRef
+        {
+            get => this.Fields[(int)WixFormatFilesSymbolFields.FileRef].AsString();
+            set => this.Set((int)WixFormatFilesSymbolFields.FileRef, value);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/ext/Util/wixext/Symbols/WixInternetShortcutSymbol.cs b/src/ext/Util/wixext/Symbols/WixInternetShortcutSymbol.cs
new file mode 100644
index 00000000..e8265e02
--- /dev/null
+++ b/src/ext/Util/wixext/Symbols/WixInternetShortcutSymbol.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.Util
+{
+    using WixToolset.Data;
+    using WixToolset.Util.Symbols;
+
+    public static partial class UtilSymbolDefinitions
+    {
+        public static readonly IntermediateSymbolDefinition WixInternetShortcut = new IntermediateSymbolDefinition(
+            UtilSymbolDefinitionType.WixInternetShortcut.ToString(),
+            new[]
+            {
+                new IntermediateFieldDefinition(nameof(WixInternetShortcutSymbolFields.ComponentRef), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(WixInternetShortcutSymbolFields.DirectoryRef), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(WixInternetShortcutSymbolFields.Name), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(WixInternetShortcutSymbolFields.Target), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(WixInternetShortcutSymbolFields.Attributes), IntermediateFieldType.Number),
+                new IntermediateFieldDefinition(nameof(WixInternetShortcutSymbolFields.IconFile), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(WixInternetShortcutSymbolFields.IconIndex), IntermediateFieldType.Number),
+            },
+            typeof(WixInternetShortcutSymbol));
+    }
+}
+
+namespace WixToolset.Util.Symbols
+{
+    using WixToolset.Data;
+
+    public enum WixInternetShortcutSymbolFields
+    {
+        ComponentRef,
+        DirectoryRef,
+        Name,
+        Target,
+        Attributes,
+        IconFile,
+        IconIndex,
+    }
+
+    public class WixInternetShortcutSymbol : IntermediateSymbol
+    {
+        public WixInternetShortcutSymbol() : base(UtilSymbolDefinitions.WixInternetShortcut, null, null)
+        {
+        }
+
+        public WixInternetShortcutSymbol(SourceLineNumber sourceLineNumber, Identifier id = null) : base(UtilSymbolDefinitions.WixInternetShortcut, sourceLineNumber, id)
+        {
+        }
+
+        public IntermediateField this[WixInternetShortcutSymbolFields index] => this.Fields[(int)index];
+
+        public string ComponentRef
+        {
+            get => this.Fields[(int)WixInternetShortcutSymbolFields.ComponentRef].AsString();
+            set => this.Set((int)WixInternetShortcutSymbolFields.ComponentRef, value);
+        }
+
+        public string DirectoryRef
+        {
+            get => this.Fields[(int)WixInternetShortcutSymbolFields.DirectoryRef].AsString();
+            set => this.Set((int)WixInternetShortcutSymbolFields.DirectoryRef, value);
+        }
+
+        public string Name
+        {
+            get => this.Fields[(int)WixInternetShortcutSymbolFields.Name].AsString();
+            set => this.Set((int)WixInternetShortcutSymbolFields.Name, value);
+        }
+
+        public string Target
+        {
+            get => this.Fields[(int)WixInternetShortcutSymbolFields.Target].AsString();
+            set => this.Set((int)WixInternetShortcutSymbolFields.Target, value);
+        }
+
+        public int Attributes
+        {
+            get => this.Fields[(int)WixInternetShortcutSymbolFields.Attributes].AsNumber();
+            set => this.Set((int)WixInternetShortcutSymbolFields.Attributes, value);
+        }
+
+        public string IconFile
+        {
+            get => this.Fields[(int)WixInternetShortcutSymbolFields.IconFile].AsString();
+            set => this.Set((int)WixInternetShortcutSymbolFields.IconFile, value);
+        }
+
+        public int? IconIndex
+        {
+            get => this.Fields[(int)WixInternetShortcutSymbolFields.IconIndex].AsNullableNumber();
+            set => this.Set((int)WixInternetShortcutSymbolFields.IconIndex, value);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/ext/Util/wixext/Symbols/WixRemoveFolderExSymbol.cs b/src/ext/Util/wixext/Symbols/WixRemoveFolderExSymbol.cs
new file mode 100644
index 00000000..86352b6c
--- /dev/null
+++ b/src/ext/Util/wixext/Symbols/WixRemoveFolderExSymbol.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.Util
+{
+    using WixToolset.Data;
+    using WixToolset.Util.Symbols;
+
+    public static partial class UtilSymbolDefinitions
+    {
+        public static readonly IntermediateSymbolDefinition WixRemoveFolderEx = new IntermediateSymbolDefinition(
+            UtilSymbolDefinitionType.WixRemoveFolderEx.ToString(),
+            new[]
+            {
+                new IntermediateFieldDefinition(nameof(WixRemoveFolderExSymbolFields.ComponentRef), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(WixRemoveFolderExSymbolFields.Property), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(WixRemoveFolderExSymbolFields.InstallMode), IntermediateFieldType.Number),
+                new IntermediateFieldDefinition(nameof(WixRemoveFolderExSymbolFields.Condition), IntermediateFieldType.String),
+            },
+            typeof(WixRemoveFolderExSymbol));
+    }
+}
+
+namespace WixToolset.Util.Symbols
+{
+    using WixToolset.Data;
+
+    public enum WixRemoveFolderExSymbolFields
+    {
+        ComponentRef,
+        Property,
+        InstallMode,
+        Condition,
+    }
+
+    public enum WixRemoveFolderExInstallMode
+    {
+        Install = 1,
+        Uninstall = 2,
+        Both = 3,
+    }
+
+    public class WixRemoveFolderExSymbol : IntermediateSymbol
+    {
+        public WixRemoveFolderExSymbol() : base(UtilSymbolDefinitions.WixRemoveFolderEx, null, null)
+        {
+        }
+
+        public WixRemoveFolderExSymbol(SourceLineNumber sourceLineNumber, Identifier id = null) : base(UtilSymbolDefinitions.WixRemoveFolderEx, sourceLineNumber, id)
+        {
+        }
+
+        public IntermediateField this[WixRemoveFolderExSymbolFields index] => this.Fields[(int)index];
+
+        public string ComponentRef
+        {
+            get => this.Fields[(int)WixRemoveFolderExSymbolFields.ComponentRef].AsString();
+            set => this.Set((int)WixRemoveFolderExSymbolFields.ComponentRef, value);
+        }
+
+        public string Property
+        {
+            get => this.Fields[(int)WixRemoveFolderExSymbolFields.Property].AsString();
+            set => this.Set((int)WixRemoveFolderExSymbolFields.Property, value);
+        }
+
+        public WixRemoveFolderExInstallMode InstallMode
+        {
+            get => (WixRemoveFolderExInstallMode)this.Fields[(int)WixRemoveFolderExSymbolFields.InstallMode].AsNumber();
+            set => this.Set((int)WixRemoveFolderExSymbolFields.InstallMode, (int)value);
+        }
+
+        public string Condition
+        {
+            get => this.Fields[(int)WixRemoveFolderExSymbolFields.Condition].AsString();
+            set => this.Set((int)WixRemoveFolderExSymbolFields.Condition, value);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/ext/Util/wixext/Symbols/WixRemoveRegistryKeyExSymbol.cs b/src/ext/Util/wixext/Symbols/WixRemoveRegistryKeyExSymbol.cs
new file mode 100644
index 00000000..8e4bd212
--- /dev/null
+++ b/src/ext/Util/wixext/Symbols/WixRemoveRegistryKeyExSymbol.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.Util
+{
+    using WixToolset.Data;
+    using WixToolset.Util.Symbols;
+
+    public static partial class UtilSymbolDefinitions
+    {
+        public static readonly IntermediateSymbolDefinition WixRemoveRegistryKeyEx = new IntermediateSymbolDefinition(
+            UtilSymbolDefinitionType.WixRemoveRegistryKeyEx.ToString(),
+            new[]
+            {
+                new IntermediateFieldDefinition(nameof(WixRemoveRegistryKeyExSymbolFields.ComponentRef), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(WixRemoveRegistryKeyExSymbolFields.Root), IntermediateFieldType.Number),
+                new IntermediateFieldDefinition(nameof(WixRemoveRegistryKeyExSymbolFields.Key), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(WixRemoveRegistryKeyExSymbolFields.InstallMode), IntermediateFieldType.Number),
+                new IntermediateFieldDefinition(nameof(WixRemoveRegistryKeyExSymbolFields.Condition), IntermediateFieldType.String),
+            },
+            typeof(WixRemoveRegistryKeyExSymbol));
+    }
+}
+
+namespace WixToolset.Util.Symbols
+{
+    using WixToolset.Data;
+    using WixToolset.Data.Symbols;
+
+    public enum WixRemoveRegistryKeyExSymbolFields
+    {
+        ComponentRef,
+        Root,
+        Key,
+        InstallMode,
+        Condition,
+    }
+
+    public enum WixRemoveRegistryKeyExInstallMode
+    {
+        Install = 1,
+        Uninstall = 2,
+    }
+
+    public class WixRemoveRegistryKeyExSymbol : IntermediateSymbol
+    {
+        public WixRemoveRegistryKeyExSymbol() : base(UtilSymbolDefinitions.WixRemoveRegistryKeyEx, null, null)
+        {
+        }
+
+        public WixRemoveRegistryKeyExSymbol(SourceLineNumber sourceLineNumber, Identifier id = null) : base(UtilSymbolDefinitions.WixRemoveRegistryKeyEx, sourceLineNumber, id)
+        {
+        }
+
+        public IntermediateField this[WixRemoveRegistryKeyExSymbolFields index] => this.Fields[(int)index];
+
+        public string ComponentRef
+        {
+            get => this.Fields[(int)WixRemoveRegistryKeyExSymbolFields.ComponentRef].AsString();
+            set => this.Set((int)WixRemoveRegistryKeyExSymbolFields.ComponentRef, value);
+        }
+
+        public RegistryRootType Root
+        {
+            get => (RegistryRootType)this.Fields[(int)WixRemoveRegistryKeyExSymbolFields.Root].AsNumber();
+            set => this.Set((int)WixRemoveRegistryKeyExSymbolFields.Root, (int)value);
+        }
+
+        public string Key
+        {
+            get => (string)this.Fields[(int)WixRemoveRegistryKeyExSymbolFields.Key];
+            set => this.Set((int)WixRemoveRegistryKeyExSymbolFields.Key, value);
+        }
+
+        public WixRemoveRegistryKeyExInstallMode InstallMode
+        {
+            get => (WixRemoveRegistryKeyExInstallMode)this.Fields[(int)WixRemoveRegistryKeyExSymbolFields.InstallMode].AsNumber();
+            set => this.Set((int)WixRemoveRegistryKeyExSymbolFields.InstallMode, (int)value);
+        }
+
+        public string Condition
+        {
+            get => this.Fields[(int)WixRemoveRegistryKeyExSymbolFields.Condition].AsString();
+            set => this.Set((int)WixRemoveRegistryKeyExSymbolFields.Condition, value);
+        }
+    }
+}
diff --git a/src/ext/Util/wixext/Symbols/WixRestartResourceSymbol.cs b/src/ext/Util/wixext/Symbols/WixRestartResourceSymbol.cs
new file mode 100644
index 00000000..01b92b63
--- /dev/null
+++ b/src/ext/Util/wixext/Symbols/WixRestartResourceSymbol.cs
@@ -0,0 +1,71 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved. Licensed under the Microsoft Reciprocal License. See LICENSE.TXT file in the project root for full license information.
+
+namespace WixToolset.Util
+{
+    using WixToolset.Data;
+    using WixToolset.Util.Symbols;
+
+    public static partial class UtilSymbolDefinitions
+    {
+        public static readonly IntermediateSymbolDefinition WixRestartResource = new IntermediateSymbolDefinition(
+            UtilSymbolDefinitionType.WixRestartResource.ToString(),
+            new[]
+            {
+                new IntermediateFieldDefinition(nameof(WixRestartResourceSymbolFields.ComponentRef), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(WixRestartResourceSymbolFields.Resource), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(WixRestartResourceSymbolFields.Attributes), IntermediateFieldType.Number),
+            },
+            typeof(WixRestartResourceSymbol));
+    }
+}
+
+namespace WixToolset.Util.Symbols
+{
+    using WixToolset.Data;
+
+    public enum WixRestartResourceSymbolFields
+    {
+        ComponentRef,
+        Resource,
+        Attributes,
+    }
+
+    public enum WixRestartResourceAttributes
+    {
+        Filename = 1,
+        ProcessName,
+        ServiceName,
+        TypeMask = 0xf,
+    }
+
+    public class WixRestartResourceSymbol : IntermediateSymbol
+    {
+        public WixRestartResourceSymbol() : base(UtilSymbolDefinitions.WixRestartResource, null, null)
+        {
+        }
+
+        public WixRestartResourceSymbol(SourceLineNumber sourceLineNumber, Identifier id = null) : base(UtilSymbolDefinitions.WixRestartResource, sourceLineNumber, id)
+        {
+        }
+
+        public IntermediateField this[WixRestartResourceSymbolFields index] => this.Fields[(int)index];
+
+        public string ComponentRef
+        {
+            get => this.Fields[(int)WixRestartResourceSymbolFields.ComponentRef].AsString();
+            set => this.Set((int)WixRestartResourceSymbolFields.ComponentRef, value);
+        }
+
+        public string Resource
+        {
+            get => this.Fields[(int)WixRestartResourceSymbolFields.Resource].AsString();
+            set => this.Set((int)WixRestartResourceSymbolFields.Resource, value);
+        }
+
+        public WixRestartResourceAttributes? Attributes
+        {
+            get => (WixRestartResourceAttributes?)this.Fields[(int)WixRestartResourceSymbolFields.Attributes].AsNullableNumber();
+            set => this.Set((int)WixRestartResourceSymbolFields.Attributes, (int?)value);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/ext/Util/wixext/Symbols/WixTouchFileSymbol.cs b/src/ext/Util/wixext/Symbols/WixTouchFileSymbol.cs
new file mode 100644
index 00000000..447c21ba
--- /dev/null
+++ b/src/ext/Util/wixext/Symbols/WixTouchFileSymbol.cs
@@ -0,0 +1,63 @@
+// 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.Util
+{
+    using WixToolset.Data;
+    using WixToolset.Util.Symbols;
+
+    public static partial class UtilSymbolDefinitions
+    {
+        public static readonly IntermediateSymbolDefinition WixTouchFile = new IntermediateSymbolDefinition(
+            UtilSymbolDefinitionType.WixTouchFile.ToString(),
+            new[]
+            {
+                new IntermediateFieldDefinition(nameof(WixTouchFileSymbolFields.ComponentRef), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(WixTouchFileSymbolFields.Path), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(WixTouchFileSymbolFields.Attributes), IntermediateFieldType.Number),
+            },
+            typeof(WixTouchFileSymbol));
+    }
+}
+
+namespace WixToolset.Util.Symbols
+{
+    using WixToolset.Data;
+
+    public enum WixTouchFileSymbolFields
+    {
+        ComponentRef,
+        Path,
+        Attributes,
+    }
+
+    public class WixTouchFileSymbol : IntermediateSymbol
+    {
+        public WixTouchFileSymbol() : base(UtilSymbolDefinitions.WixTouchFile, null, null)
+        {
+        }
+
+        public WixTouchFileSymbol(SourceLineNumber sourceLineNumber, Identifier id = null) : base(UtilSymbolDefinitions.WixTouchFile, sourceLineNumber, id)
+        {
+        }
+
+        public IntermediateField this[WixTouchFileSymbolFields index] => this.Fields[(int)index];
+
+        public string ComponentRef
+        {
+            get => this.Fields[(int)WixTouchFileSymbolFields.ComponentRef].AsString();
+            set => this.Set((int)WixTouchFileSymbolFields.ComponentRef, value);
+        }
+
+        public string Path
+        {
+            get => this.Fields[(int)WixTouchFileSymbolFields.Path].AsString();
+            set => this.Set((int)WixTouchFileSymbolFields.Path, value);
+        }
+
+        public int Attributes
+        {
+            get => this.Fields[(int)WixTouchFileSymbolFields.Attributes].AsNumber();
+            set => this.Set((int)WixTouchFileSymbolFields.Attributes, value);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/ext/Util/wixext/Symbols/WixWindowsFeatureSearchSymbol.cs b/src/ext/Util/wixext/Symbols/WixWindowsFeatureSearchSymbol.cs
new file mode 100644
index 00000000..9a43692c
--- /dev/null
+++ b/src/ext/Util/wixext/Symbols/WixWindowsFeatureSearchSymbol.cs
@@ -0,0 +1,47 @@
+// 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.Util
+{
+    using WixToolset.Data;
+    using WixToolset.Util.Symbols;
+
+    public static partial class UtilSymbolDefinitions
+    {
+        public static readonly IntermediateSymbolDefinition WixWindowsFeatureSearch = new IntermediateSymbolDefinition(
+            UtilSymbolDefinitionType.WixWindowsFeatureSearch.ToString(),
+            new[]
+            {
+                new IntermediateFieldDefinition(nameof(WixWindowsFeatureSearchSymbolFields.Type), IntermediateFieldType.String),
+            },
+            typeof(WixWindowsFeatureSearchSymbol));
+    }
+}
+
+namespace WixToolset.Util.Symbols
+{
+    using WixToolset.Data;
+
+    public enum WixWindowsFeatureSearchSymbolFields
+    {
+        Type,
+    }
+
+    public class WixWindowsFeatureSearchSymbol : IntermediateSymbol
+    {
+        public WixWindowsFeatureSearchSymbol() : base(UtilSymbolDefinitions.WixWindowsFeatureSearch, null, null)
+        {
+        }
+
+        public WixWindowsFeatureSearchSymbol(SourceLineNumber sourceLineNumber, Identifier id = null) : base(UtilSymbolDefinitions.WixWindowsFeatureSearch, sourceLineNumber, id)
+        {
+        }
+
+        public IntermediateField this[WixWindowsFeatureSearchSymbolFields index] => this.Fields[(int)index];
+
+        public string Type
+        {
+            get => this.Fields[(int)WixWindowsFeatureSearchSymbolFields.Type].AsString();
+            set => this.Set((int)WixWindowsFeatureSearchSymbolFields.Type, value);
+        }
+    }
+}
diff --git a/src/ext/Util/wixext/Symbols/XmlConfigSymbol.cs b/src/ext/Util/wixext/Symbols/XmlConfigSymbol.cs
new file mode 100644
index 00000000..6503a586
--- /dev/null
+++ b/src/ext/Util/wixext/Symbols/XmlConfigSymbol.cs
@@ -0,0 +1,111 @@
+// 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.Util
+{
+    using WixToolset.Data;
+    using WixToolset.Util.Symbols;
+
+    public static partial class UtilSymbolDefinitions
+    {
+        public static readonly IntermediateSymbolDefinition XmlConfig = new IntermediateSymbolDefinition(
+            UtilSymbolDefinitionType.XmlConfig.ToString(),
+            new[]
+            {
+                new IntermediateFieldDefinition(nameof(XmlConfigSymbolFields.File), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(XmlConfigSymbolFields.ElementId), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(XmlConfigSymbolFields.ElementPath), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(XmlConfigSymbolFields.VerifyPath), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(XmlConfigSymbolFields.Name), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(XmlConfigSymbolFields.Value), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(XmlConfigSymbolFields.Flags), IntermediateFieldType.Number),
+                new IntermediateFieldDefinition(nameof(XmlConfigSymbolFields.ComponentRef), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(XmlConfigSymbolFields.Sequence), IntermediateFieldType.Number),
+            },
+            typeof(XmlConfigSymbol));
+    }
+}
+
+namespace WixToolset.Util.Symbols
+{
+    using WixToolset.Data;
+
+    public enum XmlConfigSymbolFields
+    {
+        File,
+        ElementId,
+        ElementPath,
+        VerifyPath,
+        Name,
+        Value,
+        Flags,
+        ComponentRef,
+        Sequence,
+    }
+
+    public class XmlConfigSymbol : IntermediateSymbol
+    {
+        public XmlConfigSymbol() : base(UtilSymbolDefinitions.XmlConfig, null, null)
+        {
+        }
+
+        public XmlConfigSymbol(SourceLineNumber sourceLineNumber, Identifier id = null) : base(UtilSymbolDefinitions.XmlConfig, sourceLineNumber, id)
+        {
+        }
+
+        public IntermediateField this[XmlConfigSymbolFields index] => this.Fields[(int)index];
+
+        public string File
+        {
+            get => this.Fields[(int)XmlConfigSymbolFields.File].AsString();
+            set => this.Set((int)XmlConfigSymbolFields.File, value);
+        }
+
+        public string ElementId
+        {
+            get => this.Fields[(int)XmlConfigSymbolFields.ElementId].AsString();
+            set => this.Set((int)XmlConfigSymbolFields.ElementId, value);
+        }
+
+        public string ElementPath
+        {
+            get => this.Fields[(int)XmlConfigSymbolFields.ElementPath].AsString();
+            set => this.Set((int)XmlConfigSymbolFields.ElementPath, value);
+        }
+
+        public string VerifyPath
+        {
+            get => this.Fields[(int)XmlConfigSymbolFields.VerifyPath].AsString();
+            set => this.Set((int)XmlConfigSymbolFields.VerifyPath, value);
+        }
+
+        public string Name
+        {
+            get => this.Fields[(int)XmlConfigSymbolFields.Name].AsString();
+            set => this.Set((int)XmlConfigSymbolFields.Name, value);
+        }
+
+        public string Value
+        {
+            get => this.Fields[(int)XmlConfigSymbolFields.Value].AsString();
+            set => this.Set((int)XmlConfigSymbolFields.Value, value);
+        }
+
+        public int Flags
+        {
+            get => this.Fields[(int)XmlConfigSymbolFields.Flags].AsNumber();
+            set => this.Set((int)XmlConfigSymbolFields.Flags, value);
+        }
+
+        public string ComponentRef
+        {
+            get => this.Fields[(int)XmlConfigSymbolFields.ComponentRef].AsString();
+            set => this.Set((int)XmlConfigSymbolFields.ComponentRef, value);
+        }
+
+        public int? Sequence
+        {
+            get => this.Fields[(int)XmlConfigSymbolFields.Sequence].AsNullableNumber();
+            set => this.Set((int)XmlConfigSymbolFields.Sequence, value);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/ext/Util/wixext/Symbols/XmlFileSymbol.cs b/src/ext/Util/wixext/Symbols/XmlFileSymbol.cs
new file mode 100644
index 00000000..7d5d991b
--- /dev/null
+++ b/src/ext/Util/wixext/Symbols/XmlFileSymbol.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.Util
+{
+    using WixToolset.Data;
+    using WixToolset.Util.Symbols;
+
+    public static partial class UtilSymbolDefinitions
+    {
+        public static readonly IntermediateSymbolDefinition XmlFile = new IntermediateSymbolDefinition(
+            UtilSymbolDefinitionType.XmlFile.ToString(),
+            new[]
+            {
+                new IntermediateFieldDefinition(nameof(XmlFileSymbolFields.File), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(XmlFileSymbolFields.ElementPath), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(XmlFileSymbolFields.Name), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(XmlFileSymbolFields.Value), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(XmlFileSymbolFields.Flags), IntermediateFieldType.Number),
+                new IntermediateFieldDefinition(nameof(XmlFileSymbolFields.ComponentRef), IntermediateFieldType.String),
+                new IntermediateFieldDefinition(nameof(XmlFileSymbolFields.Sequence), IntermediateFieldType.Number),
+            },
+            typeof(XmlFileSymbol));
+    }
+}
+
+namespace WixToolset.Util.Symbols
+{
+    using WixToolset.Data;
+
+    public enum XmlFileSymbolFields
+    {
+        File,
+        ElementPath,
+        Name,
+        Value,
+        Flags,
+        ComponentRef,
+        Sequence,
+    }
+
+    public class XmlFileSymbol : IntermediateSymbol
+    {
+        public XmlFileSymbol() : base(UtilSymbolDefinitions.XmlFile, null, null)
+        {
+        }
+
+        public XmlFileSymbol(SourceLineNumber sourceLineNumber, Identifier id = null) : base(UtilSymbolDefinitions.XmlFile, sourceLineNumber, id)
+        {
+        }
+
+        public IntermediateField this[XmlFileSymbolFields index] => this.Fields[(int)index];
+
+        public string File
+        {
+            get => this.Fields[(int)XmlFileSymbolFields.File].AsString();
+            set => this.Set((int)XmlFileSymbolFields.File, value);
+        }
+
+        public string ElementPath
+        {
+            get => this.Fields[(int)XmlFileSymbolFields.ElementPath].AsString();
+            set => this.Set((int)XmlFileSymbolFields.ElementPath, value);
+        }
+
+        public string Name
+        {
+            get => this.Fields[(int)XmlFileSymbolFields.Name].AsString();
+            set => this.Set((int)XmlFileSymbolFields.Name, value);
+        }
+
+        public string Value
+        {
+            get => this.Fields[(int)XmlFileSymbolFields.Value].AsString();
+            set => this.Set((int)XmlFileSymbolFields.Value, value);
+        }
+
+        public int Flags
+        {
+            get => this.Fields[(int)XmlFileSymbolFields.Flags].AsNumber();
+            set => this.Set((int)XmlFileSymbolFields.Flags, value);
+        }
+
+        public string ComponentRef
+        {
+            get => this.Fields[(int)XmlFileSymbolFields.ComponentRef].AsString();
+            set => this.Set((int)XmlFileSymbolFields.ComponentRef, value);
+        }
+
+        public int? Sequence
+        {
+            get => this.Fields[(int)XmlFileSymbolFields.Sequence].AsNullableNumber();
+            set => this.Set((int)XmlFileSymbolFields.Sequence, value);
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/ext/Util/wixext/UtilCompiler.cs b/src/ext/Util/wixext/UtilCompiler.cs
new file mode 100644
index 00000000..45079150
--- /dev/null
+++ b/src/ext/Util/wixext/UtilCompiler.cs
@@ -0,0 +1,3889 @@
+// 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.Util
+{
+    using System;
+    using System.Collections;
+    using System.Collections.Generic;
+    using System.Globalization;
+    using System.Linq;
+    using System.Text;
+    using System.Text.RegularExpressions;
+    using System.Xml.Linq;
+    using WixToolset.Data;
+    using WixToolset.Data.Symbols;
+    using WixToolset.Extensibility;
+    using WixToolset.Extensibility.Data;
+    using WixToolset.Util.Symbols;
+
+    /// <summary>
+    /// The compiler for the WiX Toolset Utility Extension.
+    /// </summary>
+    public sealed class UtilCompiler : BaseCompilerExtension
+    {
+        // user creation attributes definitions (from sca.h)
+        internal const int UserDontExpirePasswrd = 0x00000001;
+        internal const int UserPasswdCantChange = 0x00000002;
+        internal const int UserPasswdChangeReqdOnLogin = 0x00000004;
+        internal const int UserDisableAccount = 0x00000008;
+        internal const int UserFailIfExists = 0x00000010;
+        internal const int UserUpdateIfExists = 0x00000020;
+        internal const int UserLogonAsService = 0x00000040;
+        internal const int UserLogonAsBatchJob = 0x00000080;
+
+        internal const int UserDontRemoveOnUninstall = 0x00000100;
+        internal const int UserDontCreateUser = 0x00000200;
+        internal const int UserNonVital = 0x00000400;
+
+        private static readonly Regex FindPropertyBrackets = new Regex(@"\[(?!\\|\])|(?<!\[\\\]|\[\\|\\\[)\]", RegexOptions.ExplicitCapture | RegexOptions.Compiled);
+
+        public override XNamespace Namespace => "http://wixtoolset.org/schemas/v4/wxs/util";
+
+        /// <summary>
+        /// Types of Internet shortcuts.
+        /// </summary>
+        public enum InternetShortcutType
+        {
+            /// <summary>Create a .lnk file.</summary>
+            Link = 0,
+
+            /// <summary>Create a .url file.</summary>
+            Url,
+        }
+
+        /// <summary>
+        /// Types of permission setting methods.
+        /// </summary>
+        private enum PermissionType
+        {
+            /// <summary>LockPermissions (normal) type permission setting.</summary>
+            LockPermissions,
+
+            /// <summary>FileSharePermissions type permission setting.</summary>
+            FileSharePermissions,
+
+            /// <summary>SecureObjects type permission setting.</summary>
+            SecureObjects,
+        }
+
+        /// <summary>
+        /// Processes an element for the Compiler.
+        /// </summary>
+        /// <param name="parentElement">Parent element of element to process.</param>
+        /// <param name="element">Element to process.</param>
+        /// <param name="context">Extra information about the context in which this element is being parsed.</param>
+        public override void ParseElement(Intermediate intermediate, IntermediateSection section, XElement parentElement, XElement element, IDictionary<string, string> context)
+        {
+            this.ParsePossibleKeyPathElement(intermediate, section, parentElement, element, context);
+        }
+
+        /// <summary>
+        /// Processes an element for the Compiler.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line number for the parent element.</param>
+        /// <param name="parentElement">Parent element of element to process.</param>
+        /// <param name="element">Element to process.</param>
+        /// <param name="contextValues">Extra information about the context in which this element is being parsed.</param>
+        public override IComponentKeyPath ParsePossibleKeyPathElement(Intermediate intermediate, IntermediateSection section, XElement parentElement, XElement element, IDictionary<string, string> context)
+        {
+            IComponentKeyPath possibleKeyPath = null;
+
+            switch (parentElement.Name.LocalName)
+            {
+                case "CreateFolder":
+                    var createFolderId = context["DirectoryId"];
+                    var createFolderComponentId = context["ComponentId"];
+
+                    // If this doesn't parse successfully, something really odd is going on, so let the exception get thrown
+                    var createFolderWin64 = Boolean.Parse(context["Win64"]);
+
+                    switch (element.Name.LocalName)
+                    {
+                        case "PermissionEx":
+                            this.ParsePermissionExElement(intermediate, section, element, createFolderId, createFolderComponentId, createFolderWin64, "CreateFolder");
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedElement(parentElement, element);
+                            break;
+                    }
+                    break;
+                case "Component":
+                    var componentId = context["ComponentId"];
+                    var directoryId = context["DirectoryId"];
+                    var componentWin64 = Boolean.Parse(context["Win64"]);
+
+                    switch (element.Name.LocalName)
+                    {
+                        case "EventSource":
+                            possibleKeyPath = this.ParseEventSourceElement(intermediate, section, element, componentId);
+                            break;
+                        case "FileShare":
+                            this.ParseFileShareElement(intermediate, section, element, componentId, directoryId);
+                            break;
+                        case "InternetShortcut":
+                            this.ParseInternetShortcutElement(intermediate, section, element, componentId, directoryId);
+                            break;
+                        case "PerformanceCategory":
+                            this.ParsePerformanceCategoryElement(intermediate, section, element, componentId);
+                            break;
+                        case "RemoveFolderEx":
+                            this.ParseRemoveFolderExElement(intermediate, section, element, componentId);
+                            break;
+                        case "RemoveRegistryKey":
+                            this.ParseRemoveRegistryKeyExElement(intermediate, section, element, componentId);
+                            break;
+                        case "RestartResource":
+                            this.ParseRestartResourceElement(intermediate, section, element, componentId);
+                            break;
+                        case "ServiceConfig":
+                            this.ParseServiceConfigElement(intermediate, section, element, componentId, "Component", null);
+                            break;
+                        case "TouchFile":
+                            this.ParseTouchFileElement(intermediate, section, element, componentId, componentWin64);
+                            break;
+                        case "User":
+                            this.ParseUserElement(intermediate, section, element, componentId);
+                            break;
+                        case "XmlFile":
+                            this.ParseXmlFileElement(intermediate, section, element, componentId);
+                            break;
+                        case "XmlConfig":
+                            this.ParseXmlConfigElement(intermediate, section, element, componentId, false);
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedElement(parentElement, element);
+                            break;
+                    }
+                    break;
+                case "File":
+                    var fileId = context["FileId"];
+                    var fileComponentId = context["ComponentId"];
+
+                    // If this doesn't parse successfully, something really odd is going on, so let the exception get thrown
+                    var fileWin64 = Boolean.Parse(context["Win64"]);
+
+                    switch (element.Name.LocalName)
+                    {
+                        case "PerfCounter":
+                            this.ParsePerfCounterElement(intermediate, section, element, fileComponentId, fileId);
+                            break;
+                        case "PermissionEx":
+                            this.ParsePermissionExElement(intermediate, section, element, fileId, fileComponentId, fileWin64, "File");
+                            break;
+                        case "PerfCounterManifest":
+                            this.ParsePerfCounterManifestElement(intermediate, section, element, fileComponentId, fileId);
+                            break;
+                        case "EventManifest":
+                            this.ParseEventManifestElement(intermediate, section, element, fileComponentId, fileId);
+                            break;
+                        case "FormatFile":
+                            this.ParseFormatFileElement(intermediate, section, element, fileId, fileWin64);
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedElement(parentElement, element);
+                            break;
+                    }
+                    break;
+                case "Bundle":
+                case "Fragment":
+                case "Module":
+                case "Package":
+                    switch (element.Name.LocalName)
+                    {
+                        case "CloseApplication":
+                            this.ParseCloseApplicationElement(intermediate, section, element);
+                            break;
+                        case "Group":
+                            this.ParseGroupElement(intermediate, section, element, null);
+                            break;
+                        case "RestartResource":
+                            // Currently not supported for Bundles.
+                            if (parentElement.Name.LocalName != "Bundle")
+                            {
+                                this.ParseRestartResourceElement(intermediate, section, element, null);
+                            }
+                            else
+                            {
+                                this.ParseHelper.UnexpectedElement(parentElement, element);
+                            }
+                            break;
+                        case "User":
+                            this.ParseUserElement(intermediate, section, element, null);
+                            break;
+                        case "BroadcastEnvironmentChange":
+                        case "BroadcastSettingChange":
+                        case "CheckRebootRequired":
+                        case "ExitEarlyWithSuccess":
+                        case "FailWhenDeferred":
+                        case "QueryWindowsDirectories":
+                        case "QueryWindowsDriverInfo":
+                        case "QueryWindowsSuiteInfo":
+                        case "QueryWindowsWellKnownSIDs":
+                        case "WaitForEvent":
+                        case "WaitForEventDeferred":
+                            this.AddCustomActionReference(intermediate, section, element, parentElement);
+                            break;
+                        case "ComponentSearch":
+                        case "ComponentSearchRef":
+                        case "DirectorySearch":
+                        case "DirectorySearchRef":
+                        case "FileSearch":
+                        case "FileSearchRef":
+                        case "ProductSearch":
+                        case "ProductSearchRef":
+                        case "RegistrySearch":
+                        case "RegistrySearchRef":
+                        case "WindowsFeatureSearch":
+                        case "WindowsFeatureSearchRef":
+                            // These will eventually be supported under Module/Product, but are not yet.
+                            if (parentElement.Name.LocalName == "Bundle" || parentElement.Name.LocalName == "Fragment")
+                            {
+                                // TODO: When these are supported by all section types, move
+                                // these out of the nested switch and back into the surrounding one.
+                                switch (element.Name.LocalName)
+                                {
+                                    case "ComponentSearch":
+                                        this.ParseComponentSearchElement(intermediate, section, element);
+                                        break;
+                                    case "ComponentSearchRef":
+                                        this.ParseComponentSearchRefElement(intermediate, section, element);
+                                        break;
+                                    case "DirectorySearch":
+                                        this.ParseDirectorySearchElement(intermediate, section, element);
+                                        break;
+                                    case "DirectorySearchRef":
+                                        this.ParseWixSearchRefElement(intermediate, section, element);
+                                        break;
+                                    case "FileSearch":
+                                        this.ParseFileSearchElement(intermediate, section, element);
+                                        break;
+                                    case "FileSearchRef":
+                                        this.ParseWixSearchRefElement(intermediate, section, element);
+                                        break;
+                                    case "ProductSearch":
+                                        this.ParseProductSearchElement(intermediate, section, element);
+                                        break;
+                                    case "ProductSearchRef":
+                                        this.ParseWixSearchRefElement(intermediate, section, element);
+                                        break;
+                                    case "RegistrySearch":
+                                        this.ParseRegistrySearchElement(intermediate, section, element);
+                                        break;
+                                    case "RegistrySearchRef":
+                                        this.ParseWixSearchRefElement(intermediate, section, element);
+                                        break;
+                                    case "WindowsFeatureSearch":
+                                        this.ParseWindowsFeatureSearchElement(intermediate, section, element);
+                                        break;
+                                    case "WindowsFeatureSearchRef":
+                                        this.ParseWindowsFeatureSearchRefElement(intermediate, section, element);
+                                        break;
+                                }
+                            }
+                            else
+                            {
+                                this.ParseHelper.UnexpectedElement(parentElement, element);
+                            }
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedElement(parentElement, element);
+                            break;
+                    }
+                    break;
+                case "Registry":
+                case "RegistryKey":
+                case "RegistryValue":
+                    var registryId = context["RegistryId"];
+                    var registryComponentId = context["ComponentId"];
+
+                    // If this doesn't parse successfully, something really odd is going on, so let the exception get thrown
+                    var registryWin64 = Boolean.Parse(context["Win64"]);
+
+                    switch (element.Name.LocalName)
+                    {
+                        case "PermissionEx":
+                            this.ParsePermissionExElement(intermediate, section, element, registryId, registryComponentId, registryWin64, "Registry");
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedElement(parentElement, element);
+                            break;
+                    }
+                    break;
+                case "ServiceInstall":
+                    var serviceInstallId = context["ServiceInstallId"];
+                    var serviceInstallName = context["ServiceInstallName"];
+                    var serviceInstallComponentId = context["ServiceInstallComponentId"];
+
+                    // If this doesn't parse successfully, something really odd is going on, so let the exception get thrown
+                    var serviceInstallWin64 = Boolean.Parse(context["Win64"]);
+
+                    switch (element.Name.LocalName)
+                    {
+                        case "PermissionEx":
+                            this.ParsePermissionExElement(intermediate, section, element, serviceInstallId, serviceInstallComponentId, serviceInstallWin64, "ServiceInstall");
+                            break;
+                        case "ServiceConfig":
+                            this.ParseServiceConfigElement(intermediate, section, element, serviceInstallComponentId, "ServiceInstall", serviceInstallName);
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedElement(parentElement, element);
+                            break;
+                    }
+                    break;
+                case "UI":
+                    switch (element.Name.LocalName)
+                    {
+                        case "BroadcastEnvironmentChange":
+                        case "BroadcastSettingChange":
+                        case "CheckRebootRequired":
+                        case "ExitEarlyWithSuccess":
+                        case "FailWhenDeferred":
+                        case "QueryWindowsDirectories":
+                        case "QueryWindowsDriverInfo":
+                        case "QueryWindowsSuiteInfo":
+                        case "QueryWindowsWellKnownSIDs":
+                        case "WaitForEvent":
+                        case "WaitForEventDeferred":
+                            this.AddCustomActionReference(intermediate, section, element, parentElement);
+                            break;
+                    }
+                    break;
+                default:
+                    this.ParseHelper.UnexpectedElement(parentElement, element);
+                    break;
+            }
+
+            return possibleKeyPath;
+        }
+
+        private void AddCustomActionReference(Intermediate intermediate, IntermediateSection section, XElement element, XElement parentElement)
+        {
+            // These elements are not supported for bundles.
+            if (parentElement.Name.LocalName == "Bundle")
+            {
+                this.ParseHelper.UnexpectedElement(parentElement, element);
+                return;
+            }
+
+            var customAction = element.Name.LocalName;
+            switch (element.Name.LocalName)
+            {
+                case "BroadcastEnvironmentChange":
+                case "BroadcastSettingChange":
+                case "CheckRebootRequired":
+                case "ExitEarlyWithSuccess":
+                case "FailWhenDeferred":
+                case "WaitForEvent":
+                case "WaitForEventDeferred":
+                    //default: customAction = element.Name.LocalName;
+                    break;
+                case "QueryWindowsDirectories":
+                    customAction = "QueryOsDirs";
+                    break;
+                case "QueryWindowsDriverInfo":
+                    customAction = "QueryOsDriverInfo";
+                    break;
+                case "QueryWindowsSuiteInfo":
+                    customAction = "QueryOsInfo";
+                    break;
+                case "QueryWindowsWellKnownSIDs":
+                    customAction = "QueryOsWellKnownSID";
+                    break;
+            }
+
+            foreach (var attrib in element.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    // no attributes today
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib);
+                }
+            }
+
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element);
+
+            this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, element);
+
+            this.ParseHelper.CreateCustomActionReference(sourceLineNumbers, section, "Wix4" + customAction, this.Context.Platform, CustomActionPlatforms.X86 | CustomActionPlatforms.X64 | CustomActionPlatforms.ARM64);
+        }
+
+        /// <summary>
+        /// Parses the common search attributes shared across all searches.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line number for the parent element.</param>
+        /// <param name="attrib">Attribute to parse.</param>
+        /// <param name="id">Value of the Id attribute.</param>
+        /// <param name="variable">Value of the Variable attribute.</param>
+        /// <param name="condition">Value of the Condition attribute.</param>
+        /// <param name="after">Value of the After attribute.</param>
+        private void ParseCommonSearchAttributes(SourceLineNumber sourceLineNumbers, XAttribute attrib, ref Identifier id, ref string variable, ref string condition, ref string after)
+        {
+            switch (attrib.Name.LocalName)
+            {
+                case "Id":
+                    id = this.ParseHelper.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                    break;
+                case "Variable":
+                    variable = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                    // TODO: handle standard bundle variables
+                    break;
+                case "Condition":
+                    condition = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                    break;
+                case "After":
+                    after = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                    break;
+                default:
+                    System.Diagnostics.Debug.Assert(false);
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// Parses a ComponentSearch element.
+        /// </summary>
+        /// <param name="element">Element to parse.</param>
+        private void ParseComponentSearchElement(Intermediate intermediate, IntermediateSection section, XElement element)
+        {
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element);
+            Identifier id = null;
+            string variable = null;
+            string condition = null;
+            string after = null;
+            string guid = null;
+            string productCode = null;
+            var attributes = WixComponentSearchAttributes.KeyPath;
+
+            foreach (var attrib in element.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                        case "Variable":
+                        case "Condition":
+                        case "After":
+                            this.ParseCommonSearchAttributes(sourceLineNumbers, attrib, ref id, ref variable, ref condition, ref after);
+                            break;
+                        case "Guid":
+                            guid = this.ParseHelper.GetAttributeGuidValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ProductCode":
+                            productCode = this.ParseHelper.GetAttributeGuidValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Result":
+                            var result = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            switch (result)
+                            {
+                                case "directory":
+                                    attributes = WixComponentSearchAttributes.WantDirectory;
+                                    break;
+                                case "keyPath":
+                                    attributes = WixComponentSearchAttributes.KeyPath;
+                                    break;
+                                case "state":
+                                    attributes = WixComponentSearchAttributes.State;
+                                    break;
+                                default:
+                                    this.Messaging.Write(ErrorMessages.IllegalAttributeValue(sourceLineNumbers, attrib.Parent.Name.LocalName, attrib.Name.LocalName, result, "directory", "keyPath", "state"));
+                                    break;
+                            }
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedAttribute(element, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib);
+                }
+            }
+
+            if (null == guid)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "Guid"));
+            }
+
+            if (null == id)
+            {
+                id = this.ParseHelper.CreateIdentifier("wcs", variable, condition, after, guid, productCode, attributes.ToString());
+            }
+
+            this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, element);
+
+            this.ParseHelper.CreateWixSearchSymbol(section, sourceLineNumbers, element.Name.LocalName, id, variable, condition, after, null);
+
+            if (!this.Messaging.EncounteredError)
+            {
+                section.AddSymbol(new WixComponentSearchSymbol(sourceLineNumbers, id)
+                {
+                    Guid = guid,
+                    ProductCode = productCode,
+                    Attributes = attributes,
+                });
+            }
+        }
+
+        /// <summary>
+        /// Parses a ComponentSearchRef element
+        /// </summary>
+        /// <param name="element">Element to parse.</param>
+        private void ParseComponentSearchRefElement(Intermediate intermediate, IntermediateSection section, XElement element)
+        {
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element);
+            string refId = null;
+
+            foreach (var attrib in element.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            refId = this.ParseHelper.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.ParseHelper.CreateSimpleReference(section, sourceLineNumbers, SymbolDefinitions.WixComponentSearch, refId);
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedAttribute(element, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib);
+                }
+            }
+
+            this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, element);
+        }
+
+        /// <summary>
+        /// Parses a WindowsFeatureSearch element.
+        /// </summary>
+        /// <param name="element">Element to parse.</param>
+        private void ParseWindowsFeatureSearchElement(Intermediate intermediate, IntermediateSection section, XElement element)
+        {
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element);
+            Identifier id = null;
+            string variable = null;
+            string condition = null;
+            string after = null;
+            string feature = null;
+
+            foreach (var attrib in element.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                        case "Variable":
+                        case "Condition":
+                        case "After":
+                            this.ParseCommonSearchAttributes(sourceLineNumbers, attrib, ref id, ref variable, ref condition, ref after);
+                            break;
+                        case "Feature":
+                            feature = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            switch (feature)
+                            {
+                                case "sha2CodeSigning":
+                                    break;
+                                default:
+                                    this.Messaging.Write(ErrorMessages.IllegalAttributeValue(sourceLineNumbers, element.Name.LocalName, "Feature", feature, "sha2CodeSigning"));
+                                    break;
+                            }
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedAttribute(element, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib);
+                }
+            }
+
+            if (id == null)
+            {
+                id = this.ParseHelper.CreateIdentifier("wwfs", variable, condition, after);
+            }
+
+            if (feature == null)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "Feature"));
+            }
+
+            this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, element);
+
+            var bundleExtensionId = this.ParseHelper.CreateIdentifierValueFromPlatform("Wix4UtilBundleExtension", this.Context.Platform, BurnPlatforms.X86 | BurnPlatforms.X64 | BurnPlatforms.ARM64);
+            if (bundleExtensionId == null)
+            {
+                this.Messaging.Write(ErrorMessages.UnsupportedPlatformForElement(sourceLineNumbers, this.Context.Platform.ToString(), element.Name.LocalName));
+            }
+
+            this.ParseHelper.CreateWixSearchSymbol(section, sourceLineNumbers, element.Name.LocalName, id, variable, condition, after, bundleExtensionId);
+
+            if (!this.Messaging.EncounteredError)
+            {
+                section.AddSymbol(new WixWindowsFeatureSearchSymbol(sourceLineNumbers, id)
+                {
+                    Type = feature,
+                });
+            }
+        }
+
+        /// <summary>
+        /// Parses a WindowsFeatureSearchRef element
+        /// </summary>
+        /// <param name="element">Element to parse.</param>
+        private void ParseWindowsFeatureSearchRefElement(Intermediate intermediate, IntermediateSection section, XElement element)
+        {
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element);
+
+            foreach (var attrib in element.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            var refId = this.ParseHelper.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.ParseHelper.CreateSimpleReference(section, sourceLineNumbers, UtilSymbolDefinitions.WixWindowsFeatureSearch, refId);
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedAttribute(element, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib);
+                }
+            }
+
+            this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, element);
+        }
+
+        /// <summary>
+        /// Parses an event source element.
+        /// </summary>
+        /// <param name="element">Element to parse.</param>
+        /// <param name="componentId">Identifier of parent component.</param>
+        private IComponentKeyPath ParseEventSourceElement(Intermediate intermediate, IntermediateSection section, XElement element, string componentId)
+        {
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element);
+            string sourceName = null;
+            string logName = null;
+            string categoryMessageFile = null;
+            var categoryCount = CompilerConstants.IntegerNotSet;
+            string eventMessageFile = null;
+            string parameterMessageFile = null;
+            int typesSupported = 0;
+            var isKeyPath = false;
+
+            foreach (var attrib in element.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "CategoryCount":
+                            categoryCount = this.ParseHelper.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, Int32.MaxValue);
+                            break;
+                        case "CategoryMessageFile":
+                            categoryMessageFile = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "EventMessageFile":
+                            eventMessageFile = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "KeyPath":
+                            isKeyPath = YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Log":
+                            logName = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            if ("Security" == logName)
+                            {
+                                this.Messaging.Write(ErrorMessages.IllegalAttributeValue(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName, logName, "Application", "System", "<customEventLog>"));
+                            }
+                            break;
+                        case "Name":
+                            sourceName = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ParameterMessageFile":
+                            parameterMessageFile = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "SupportsErrors":
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                typesSupported |= 0x01; // EVENTLOG_ERROR_TYPE
+                            }
+                            break;
+                        case "SupportsFailureAudits":
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                typesSupported |= 0x10; // EVENTLOG_AUDIT_FAILURE
+                            }
+                            break;
+                        case "SupportsInformationals":
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                typesSupported |= 0x04; // EVENTLOG_INFORMATION_TYPE
+                            }
+                            break;
+                        case "SupportsSuccessAudits":
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                typesSupported |= 0x08; // EVENTLOG_AUDIT_SUCCESS
+                            }
+                            break;
+                        case "SupportsWarnings":
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                typesSupported |= 0x02; // EVENTLOG_WARNING_TYPE
+                            }
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedAttribute(element, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib);
+                }
+            }
+
+            if (null == sourceName)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "Name"));
+            }
+
+            if (null == logName)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "EventLog"));
+            }
+
+            if (null == eventMessageFile)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "EventMessageFile"));
+            }
+
+            if (null == categoryMessageFile && 0 < categoryCount)
+            {
+                this.Messaging.Write(ErrorMessages.IllegalAttributeWithoutOtherAttributes(sourceLineNumbers, element.Name.LocalName, "CategoryCount", "CategoryMessageFile"));
+            }
+
+            if (null != categoryMessageFile && CompilerConstants.IntegerNotSet == categoryCount)
+            {
+                this.Messaging.Write(ErrorMessages.IllegalAttributeWithoutOtherAttributes(sourceLineNumbers, element.Name.LocalName, "CategoryMessageFile", "CategoryCount"));
+            }
+
+            this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, element);
+
+            string eventSourceKey = $@"SYSTEM\CurrentControlSet\Services\EventLog\{logName}\{sourceName}";
+            var id = this.ParseHelper.CreateRegistrySymbol(section, sourceLineNumbers, RegistryRootType.LocalMachine, eventSourceKey, "EventMessageFile", String.Concat("#%", eventMessageFile), componentId, false);
+
+            if (null != categoryMessageFile)
+            {
+                this.ParseHelper.CreateRegistrySymbol(section, sourceLineNumbers, RegistryRootType.LocalMachine, eventSourceKey, "CategoryMessageFile", String.Concat("#%", categoryMessageFile), componentId, false);
+            }
+
+            if (CompilerConstants.IntegerNotSet != categoryCount)
+            {
+                this.ParseHelper.CreateRegistrySymbol(section, sourceLineNumbers, RegistryRootType.LocalMachine, eventSourceKey, "CategoryCount", String.Concat("#", categoryCount), componentId, false);
+            }
+
+            if (null != parameterMessageFile)
+            {
+                this.ParseHelper.CreateRegistrySymbol(section, sourceLineNumbers, RegistryRootType.LocalMachine, eventSourceKey, "ParameterMessageFile", String.Concat("#%", parameterMessageFile), componentId, false);
+            }
+
+            if (0 != typesSupported)
+            {
+                this.ParseHelper.CreateRegistrySymbol(section, sourceLineNumbers, RegistryRootType.LocalMachine, eventSourceKey, "TypesSupported", String.Concat("#", typesSupported), componentId, false);
+            }
+
+            var componentKeyPath = this.CreateComponentKeyPath();
+            componentKeyPath.Id = id.Id;
+            componentKeyPath.Explicit = isKeyPath;
+            componentKeyPath.Type = PossibleKeyPathType.Registry;
+            return componentKeyPath;
+        }
+
+        /// <summary>
+        /// Parses a close application element.
+        /// </summary>
+        /// <param name="element">Element to parse.</param>
+        private void ParseCloseApplicationElement(Intermediate intermediate, IntermediateSection section, XElement element)
+        {
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element);
+            string condition = null;
+            string description = null;
+            string target = null;
+            string property = null;
+            Identifier id = null;
+            int attributes = 2; // default to CLOSEAPP_ATTRIBUTE_REBOOTPROMPT enabled
+            var sequence = CompilerConstants.IntegerNotSet;
+            var terminateExitCode = CompilerConstants.IntegerNotSet;
+            var timeout = CompilerConstants.IntegerNotSet;
+
+            foreach (var attrib in element.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.ParseHelper.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Condition":
+                            condition = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Description":
+                            description = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Property":
+                            property = this.ParseHelper.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Sequence":
+                            sequence = this.ParseHelper.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, Int32.MaxValue);
+                            break;
+                        case "Timeout":
+                            timeout = this.ParseHelper.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, Int32.MaxValue);
+                            break;
+                        case "Target":
+                            target = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "CloseMessage":
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= 1; // CLOSEAPP_ATTRIBUTE_CLOSEMESSAGE
+                            }
+                            else
+                            {
+                                attributes &= ~1; // CLOSEAPP_ATTRIBUTE_CLOSEMESSAGE
+                            }
+                            break;
+                        case "EndSessionMessage":
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= 8; // CLOSEAPP_ATTRIBUTE_ENDSESSIONMESSAGE
+                            }
+                            else
+                            {
+                                attributes &= ~8; // CLOSEAPP_ATTRIBUTE_ENDSESSIONMESSAGE
+                            }
+                            break;
+                        case "PromptToContinue":
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= 0x40; // CLOSEAPP_ATTRIBUTE_PROMPTTOCONTINUE
+                            }
+                            else
+                            {
+                                attributes &= ~0x40; // CLOSEAPP_ATTRIBUTE_PROMPTTOCONTINUE
+                            }
+                            break;
+                        case "RebootPrompt":
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= 2; // CLOSEAPP_ATTRIBUTE_REBOOTPROMPT
+                            }
+                            else
+                            {
+                                attributes &= ~2; // CLOSEAPP_ATTRIBUTE_REBOOTPROMPT
+                            }
+                            break;
+                        case "ElevatedCloseMessage":
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= 4; // CLOSEAPP_ATTRIBUTE_ELEVATEDCLOSEMESSAGE
+                            }
+                            else
+                            {
+                                attributes &= ~4; // CLOSEAPP_ATTRIBUTE_ELEVATEDCLOSEMESSAGE
+                            }
+                            break;
+                        case "ElevatedEndSessionMessage":
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= 0x10; // CLOSEAPP_ATTRIBUTE_ELEVATEDENDSESSIONMESSAGE
+                            }
+                            else
+                            {
+                                attributes &= ~0x10; // CLOSEAPP_ATTRIBUTE_ELEVATEDENDSESSIONMESSAGE
+                            }
+                            break;
+                        case "TerminateProcess":
+                            terminateExitCode = this.ParseHelper.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, Int32.MaxValue);
+                            attributes |= 0x20; // CLOSEAPP_ATTRIBUTE_TERMINATEPROCESS
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedAttribute(element, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib);
+                }
+            }
+
+            if (null == target)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "Target"));
+            }
+            else if (null == id)
+            {
+                id = this.ParseHelper.CreateIdentifier("ca", target);
+            }
+
+            if (String.IsNullOrEmpty(description) && 0x40 == (attributes & 0x40))
+            {
+                this.Messaging.Write(ErrorMessages.IllegalAttributeValueWithoutOtherAttribute(sourceLineNumbers, element.Name.LocalName, "PromptToContinue", "yes", "Description"));
+            }
+
+            if (0x22 == (attributes & 0x22))
+            {
+                this.Messaging.Write(ErrorMessages.IllegalAttributeWithOtherAttribute(sourceLineNumbers, element.Name.LocalName, "TerminateProcess", "RebootPrompt", "yes"));
+            }
+
+            this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, element);
+
+            this.ParseHelper.CreateCustomActionReference(sourceLineNumbers, section, "Wix4CloseApplications", this.Context.Platform, CustomActionPlatforms.X86 | CustomActionPlatforms.X64 | CustomActionPlatforms.ARM64);
+
+            if (!this.Messaging.EncounteredError)
+            {
+                var symbol = section.AddSymbol(new WixCloseApplicationSymbol(sourceLineNumbers, id)
+                {
+                    Target = target,
+                    Description = description,
+                    Condition = condition,
+                    Attributes = attributes,
+                    Property = property,
+                });
+                if (CompilerConstants.IntegerNotSet != sequence)
+                {
+                    symbol.Sequence = sequence;
+                }
+                if (CompilerConstants.IntegerNotSet != terminateExitCode)
+                {
+                    symbol.TerminateExitCode = terminateExitCode;
+                }
+                if (CompilerConstants.IntegerNotSet != timeout)
+                {
+                    symbol.Timeout = timeout * 1000; // make the timeout milliseconds in the table.
+                }
+            }
+        }
+
+        /// <summary>
+        /// Parses a DirectorySearch element.
+        /// </summary>
+        /// <param name="element">Element to parse.</param>
+        private void ParseDirectorySearchElement(Intermediate intermediate, IntermediateSection section, XElement element)
+        {
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element);
+            Identifier id = null;
+            string variable = null;
+            string condition = null;
+            string after = null;
+            string path = null;
+            var attributes = WixFileSearchAttributes.IsDirectory;
+
+            foreach (var attrib in element.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                        case "Variable":
+                        case "Condition":
+                        case "After":
+                            this.ParseCommonSearchAttributes(sourceLineNumbers, attrib, ref id, ref variable, ref condition, ref after);
+                            break;
+                        case "Path":
+                            path = this.ParseHelper.GetAttributeLongFilename(sourceLineNumbers, attrib, false, true);
+                            break;
+                        case "Result":
+                            var result = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            switch (result)
+                            {
+                                case "exists":
+                                    attributes |= WixFileSearchAttributes.WantExists;
+                                    break;
+                                default:
+                                    this.Messaging.Write(ErrorMessages.IllegalAttributeValue(sourceLineNumbers, attrib.Parent.Name.LocalName, attrib.Name.LocalName, result, "exists"));
+                                    break;
+                            }
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedAttribute(element, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib);
+                }
+            }
+
+            if (null == path)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "Path"));
+            }
+
+            if (null == id)
+            {
+                id = this.ParseHelper.CreateIdentifier("wds", variable, condition, after, path, attributes.ToString());
+            }
+
+            this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, element);
+
+            this.ParseHelper.CreateWixSearchSymbol(section, sourceLineNumbers, element.Name.LocalName, id, variable, condition, after, null);
+
+            if (!this.Messaging.EncounteredError)
+            {
+                this.CreateWixFileSearchRow(section, sourceLineNumbers, id, path, attributes);
+            }
+        }
+
+        /// <summary>
+        /// Parses a DirectorySearchRef, FileSearchRef, ProductSearchRef, and RegistrySearchRef elements
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        private void ParseWixSearchRefElement(Intermediate intermediate, IntermediateSection section, XElement node)
+        {
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(node);
+
+            foreach (XAttribute attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            var refId = this.ParseHelper.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.ParseHelper.CreateSimpleReference(section, sourceLineNumbers, SymbolDefinitions.WixSearch, refId);
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, node, attrib);
+                }
+            }
+
+            this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, node);
+        }
+
+        /// <summary>
+        /// Parses a FileSearch element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        private void ParseFileSearchElement(Intermediate intermediate, IntermediateSection section, XElement node)
+        {
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(node);
+            Identifier id = null;
+            string variable = null;
+            string condition = null;
+            string after = null;
+            string path = null;
+            var attributes = WixFileSearchAttributes.Default;
+
+            foreach (var attrib in node.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                        case "Variable":
+                        case "Condition":
+                        case "After":
+                            this.ParseCommonSearchAttributes(sourceLineNumbers, attrib, ref id, ref variable, ref condition, ref after);
+                            break;
+                        case "Path":
+                            path = this.ParseHelper.GetAttributeLongFilename(sourceLineNumbers, attrib, false, true);
+                            break;
+                        case "Result":
+                            string result = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            switch (result)
+                            {
+                                case "exists":
+                                    attributes |= WixFileSearchAttributes.WantExists;
+                                    break;
+                                case "version":
+                                    attributes |= WixFileSearchAttributes.WantVersion;
+                                    break;
+                                default:
+                                    this.Messaging.Write(ErrorMessages.IllegalAttributeValue(sourceLineNumbers, attrib.Parent.Name.LocalName, attrib.Name.LocalName, result, "exists", "version"));
+                                    break;
+                            }
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedAttribute(node, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, node, attrib);
+                }
+            }
+
+            if (null == path)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, node.Name.LocalName, "Path"));
+            }
+
+            if (null == id)
+            {
+                id = this.ParseHelper.CreateIdentifier("wfs", variable, condition, after, path, attributes.ToString());
+            }
+
+            this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, node);
+
+            this.ParseHelper.CreateWixSearchSymbol(section, sourceLineNumbers, node.Name.LocalName, id, variable, condition, after, null);
+
+            if (!this.Messaging.EncounteredError)
+            {
+                this.CreateWixFileSearchRow(section, sourceLineNumbers, id, path, attributes);
+            }
+        }
+
+        /// <summary>
+        /// Creates a row in the WixFileSearch table.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line number for the parent element.</param>
+        /// <param name="id">Identifier of the search (key into the WixSearch table)</param>
+        /// <param name="path">File/directory path to search for.</param>
+        /// <param name="attributes"></param>
+        private void CreateWixFileSearchRow(IntermediateSection section, SourceLineNumber sourceLineNumbers, Identifier id, string path, WixFileSearchAttributes attributes)
+        {
+            section.AddSymbol(new WixFileSearchSymbol(sourceLineNumbers, id)
+            {
+                Path = path,
+                Attributes = attributes,
+            });
+        }
+
+        /// <summary>
+        /// Parses a file share element.
+        /// </summary>
+        /// <param name="element">Element to parse.</param>
+        /// <param name="componentId">Identifier of parent component.</param>
+        /// <param name="directoryId">Identifier of referred to directory.</param>
+        private void ParseFileShareElement(Intermediate intermediate, IntermediateSection section, XElement element, string componentId, string directoryId)
+        {
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element);
+            string description = null;
+            string name = null;
+            Identifier id = null;
+
+            foreach (var attrib in element.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.ParseHelper.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Name":
+                            name = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Description":
+                            description = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedAttribute(element, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                id = this.ParseHelper.CreateIdentifier("ufs", componentId, name);
+            }
+
+            if (null == name)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "Name"));
+            }
+
+            if (!element.Elements().Any())
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedElement(sourceLineNumbers, element.Name.LocalName, "FileSharePermission"));
+            }
+
+            foreach (var child in element.Elements())
+            {
+                if (this.Namespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "FileSharePermission":
+                            this.ParseFileSharePermissionElement(intermediate, section, child, id);
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedElement(element, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionElement(this.Context.Extensions, intermediate, section, element, child);
+                }
+            }
+
+            this.ParseHelper.CreateCustomActionReference(sourceLineNumbers, section, "Wix4ConfigureSmbInstall", this.Context.Platform, CustomActionPlatforms.X86 | CustomActionPlatforms.X64 | CustomActionPlatforms.ARM64);
+            this.ParseHelper.CreateCustomActionReference(sourceLineNumbers, section, "Wix4ConfigureSmbUninstall", this.Context.Platform, CustomActionPlatforms.X86 | CustomActionPlatforms.X64 | CustomActionPlatforms.ARM64);
+
+            if (!this.Messaging.EncounteredError)
+            {
+                section.AddSymbol(new FileShareSymbol(sourceLineNumbers, id)
+                {
+                    ShareName = name,
+                    ComponentRef = componentId,
+                    Description = description,
+                    DirectoryRef = directoryId,
+                });
+            }
+        }
+
+        /// <summary>
+        /// Parses a FileSharePermission element.
+        /// </summary>
+        /// <param name="element">Element to parse.</param>
+        /// <param name="fileShareId">The identifier of the parent FileShare element.</param>
+        private void ParseFileSharePermissionElement(Intermediate intermediate, IntermediateSection section, XElement element, Identifier fileShareId)
+        {
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element);
+            var bits = new BitArray(32);
+            string user = null;
+
+            foreach (var attrib in element.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "User":
+                            user = this.ParseHelper.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.ParseHelper.CreateSimpleReference(section, sourceLineNumbers, UtilSymbolDefinitions.User, user);
+                            break;
+                        default:
+                            var attribValue = this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            if (!this.TrySetBitFromName(UtilConstants.StandardPermissions, attrib.Name.LocalName, attribValue, bits, 16))
+                            {
+                                if (!this.TrySetBitFromName(UtilConstants.GenericPermissions, attrib.Name.LocalName, attribValue, bits, 28))
+                                {
+                                    if (!this.TrySetBitFromName(UtilConstants.FolderPermissions, attrib.Name.LocalName, attribValue, bits, 0))
+                                    {
+                                        this.ParseHelper.UnexpectedAttribute(element, attrib);
+                                        break;
+                                    }
+                                }
+                            }
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib);
+                }
+            }
+
+            var permission = this.CreateIntegerFromBitArray(bits);
+
+            if (null == user)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "User"));
+            }
+
+            if (Int32.MinValue == permission) // just GENERIC_READ, which is MSI_NULL
+            {
+                this.Messaging.Write(ErrorMessages.GenericReadNotAllowed(sourceLineNumbers));
+            }
+
+            this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, element);
+
+            if (!this.Messaging.EncounteredError)
+            {
+                section.AddSymbol(new FileSharePermissionsSymbol(sourceLineNumbers)
+                {
+                    FileShareRef = fileShareId.Id,
+                    UserRef = user,
+                    Permissions = permission,
+                });
+            }
+        }
+
+        /// <summary>
+        /// Parses a group element.
+        /// </summary>
+        /// <param name="element">Node to be parsed.</param>
+        /// <param name="componentId">Component Id of the parent component of this element.</param>
+        private void ParseGroupElement(Intermediate intermediate, IntermediateSection section, XElement element, string componentId)
+        {
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element);
+            Identifier id = null;
+            string domain = null;
+            string name = null;
+
+            foreach (var attrib in element.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.ParseHelper.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Name":
+                            name = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Domain":
+                            domain = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedAttribute(element, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                id = this.ParseHelper.CreateIdentifier("ugr", componentId, domain, name);
+            }
+
+            this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, element);
+
+            if (!this.Messaging.EncounteredError)
+            {
+                section.AddSymbol(new GroupSymbol(sourceLineNumbers, id)
+                {
+                    ComponentRef = componentId,
+                    Name = name,
+                    Domain = domain,
+                });
+            }
+        }
+
+        /// <summary>
+        /// Parses a GroupRef element
+        /// </summary>
+        /// <param name="element">Element to parse.</param>
+        /// <param name="userId">Required user id to be joined to the group.</param>
+        private void ParseGroupRefElement(Intermediate intermediate, IntermediateSection section, XElement element, string userId)
+        {
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element);
+            string groupId = null;
+
+            foreach (var attrib in element.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            groupId = this.ParseHelper.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            this.ParseHelper.CreateSimpleReference(section, sourceLineNumbers, UtilSymbolDefinitions.Group, groupId);
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedAttribute(element, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib);
+                }
+            }
+
+            this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, element);
+
+            if (!this.Messaging.EncounteredError)
+            {
+                section.AddSymbol(new UserGroupSymbol(sourceLineNumbers)
+                {
+                    UserRef = userId,
+                    GroupRef = groupId,
+                });
+            }
+        }
+
+        /// <summary>
+        /// Parses an InternetShortcut element.
+        /// </summary>
+        /// <param name="element">Element to parse.</param>
+        /// <param name="componentId">Identifier of parent component.</param>
+        /// <param name="defaultTarget">Default directory if none is specified on the InternetShortcut element.</param>
+        private void ParseInternetShortcutElement(Intermediate intermediate, IntermediateSection section, XElement element, string componentId, string defaultTarget)
+        {
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element);
+            Identifier id = null;
+            string name = null;
+            string target = null;
+            string directoryId = null;
+            string type = null;
+            string iconFile = null;
+            int iconIndex = 0;
+
+            foreach (var attrib in element.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Directory":
+                            directoryId = this.ParseHelper.GetAttributeIdentifierValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Id":
+                            id = this.ParseHelper.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Name":
+                            name = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Target":
+                            target = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Type":
+                            type = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "IconFile":
+                            iconFile = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "IconIndex":
+                            iconIndex = this.ParseHelper.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, Int32.MaxValue);
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedAttribute(element, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib);
+                }
+            }
+
+            // If there was no directoryId specified on the InternetShortcut element, default to the one on
+            // the parent component.
+            if (null == directoryId)
+            {
+                directoryId = defaultTarget;
+            }
+
+            if (null == id)
+            {
+                id = this.ParseHelper.CreateIdentifier("uis", componentId, directoryId, name, target);
+            }
+
+            // In theory this can never be the case, since InternetShortcut can only be under
+            // a component element, and if the Directory wasn't specified the default will come
+            // from the component. However, better safe than sorry, so here's a check to make sure
+            // it didn't wind up being null after setting it to the defaultTarget.
+            if (null == directoryId)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "Directory"));
+            }
+
+            if (null == name)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "Name"));
+            }
+
+            if (null == target)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "Target"));
+            }
+
+            this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, element);
+
+            var shortcutType = InternetShortcutType.Link;
+            if (String.Equals(type, "url", StringComparison.OrdinalIgnoreCase))
+            {
+                shortcutType = InternetShortcutType.Url;
+            }
+
+            if (!this.Messaging.EncounteredError)
+            {
+                this.CreateWixInternetShortcut(section, sourceLineNumbers, componentId, directoryId, id, name, target, shortcutType, iconFile, iconIndex);
+            }
+        }
+
+        /// <summary>
+        /// Creates the rows needed for WixInternetShortcut to work.
+        /// </summary>
+        /// <param name="core">The CompilerCore object used to create rows.</param>
+        /// <param name="sourceLineNumbers">Source line information about the owner element.</param>
+        /// <param name="componentId">Identifier of parent component.</param>
+        /// <param name="directoryId">Identifier of directory containing shortcut.</param>
+        /// <param name="id">Identifier of shortcut.</param>
+        /// <param name="name">Name of shortcut without extension.</param>
+        /// <param name="target">Target URL of shortcut.</param>
+        private void CreateWixInternetShortcut(IntermediateSection section, SourceLineNumber sourceLineNumbers, string componentId, string directoryId, Identifier shortcutId, string name, string target, InternetShortcutType type, string iconFile, int iconIndex)
+        {
+            // add the appropriate extension based on type of shortcut
+            name = String.Concat(name, InternetShortcutType.Url == type ? ".url" : ".lnk");
+
+            section.AddSymbol(new WixInternetShortcutSymbol(sourceLineNumbers, shortcutId)
+            {
+                ComponentRef = componentId,
+                DirectoryRef = directoryId,
+                Name = name,
+                Target = target,
+                Attributes = (int)type,
+                IconFile = iconFile,
+                IconIndex = iconIndex,
+            });
+
+            this.ParseHelper.CreateCustomActionReference(sourceLineNumbers, section, "Wix4SchedInternetShortcuts", this.Context.Platform, CustomActionPlatforms.X86 | CustomActionPlatforms.X64 | CustomActionPlatforms.ARM64);
+
+            // make sure we have a CreateFolder table so that the immediate CA can add temporary rows to handle installation and uninstallation
+            this.ParseHelper.EnsureTable(section, sourceLineNumbers, "CreateFolder");
+
+            // use built-in MSI functionality to remove the shortcuts rather than doing so via CA
+            section.AddSymbol(new RemoveFileSymbol(sourceLineNumbers, shortcutId)
+            {
+                ComponentRef = componentId,
+                DirPropertyRef = directoryId,
+                OnUninstall = true,
+                FileName = name,
+            });
+        }
+
+        /// <summary>
+        /// Parses a performance category element.
+        /// </summary>
+        /// <param name="element">Element to parse.</param>
+        /// <param name="componentId">Identifier of parent component.</param>
+        private void ParsePerformanceCategoryElement(Intermediate intermediate, IntermediateSection section, XElement element, string componentId)
+        {
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element);
+            Identifier id = null;
+            string name = null;
+            string help = null;
+            var multiInstance = YesNoType.No;
+            int defaultLanguage = 0x09; // default to "english"
+
+            var parsedPerformanceCounters = new List<ParsedPerformanceCounter>();
+
+            // default to managed performance counter
+            var library = "netfxperf.dll";
+            var openEntryPoint = "OpenPerformanceData";
+            var collectEntryPoint = "CollectPerformanceData";
+            var closeEntryPoint = "ClosePerformanceData";
+
+            foreach (var attrib in element.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Close":
+                            closeEntryPoint = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Collect":
+                            collectEntryPoint = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "DefaultLanguage":
+                            defaultLanguage = this.GetPerformanceCounterLanguage(sourceLineNumbers, attrib);
+                            break;
+                        case "Help":
+                            help = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Id":
+                            id = this.ParseHelper.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Library":
+                            library = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "MultiInstance":
+                            multiInstance = this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Name":
+                            name = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Open":
+                            openEntryPoint = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedAttribute(element, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib);
+                }
+            }
+
+            if (null == id && null == name)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttributes(sourceLineNumbers, element.Name.LocalName, "Id", "Name"));
+            }
+            else if (null == id)
+            {
+                id = this.ParseHelper.CreateIdentifier("upc", componentId, name);
+            }
+            else if (null == name)
+            {
+                name = id.Id;
+            }
+
+            // Process the child counter elements.
+            foreach (var child in element.Elements())
+            {
+                if (this.Namespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "PerformanceCounter":
+                            var counter = this.ParsePerformanceCounterElement(intermediate, section, child, defaultLanguage);
+                            if (null != counter)
+                            {
+                                parsedPerformanceCounters.Add(counter);
+                            }
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedElement(element, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionElement(this.Context.Extensions, intermediate, section, element, child);
+                }
+            }
+
+
+            if (!this.Messaging.EncounteredError)
+            {
+                // Calculate the ini and h file content.
+                var objectName = "OBJECT_1";
+                var objectLanguage = defaultLanguage.ToString("D3", CultureInfo.InvariantCulture);
+
+                var sbIniData = new StringBuilder();
+                sbIniData.AppendFormat("[info]\r\ndrivername={0}\r\nsymbolfile=wixperf.h\r\n\r\n[objects]\r\n{1}_{2}_NAME=\r\n\r\n[languages]\r\n{2}=LANG{2}\r\n\r\n", name, objectName, objectLanguage);
+                sbIniData.AppendFormat("[text]\r\n{0}_{1}_NAME={2}\r\n", objectName, objectLanguage, name);
+                if (null != help)
+                {
+                    sbIniData.AppendFormat("{0}_{1}_HELP={2}\r\n", objectName, objectLanguage, help);
+                }
+
+                int symbolConstantsCounter = 0;
+                var sbSymbolicConstants = new StringBuilder();
+                sbSymbolicConstants.AppendFormat("#define {0}    {1}\r\n", objectName, symbolConstantsCounter);
+
+                var sbCounterNames = new StringBuilder("[~]");
+                var sbCounterTypes = new StringBuilder("[~]");
+                for (int i = 0; i < parsedPerformanceCounters.Count; ++i)
+                {
+                    var counter = parsedPerformanceCounters[i];
+                    var counterName = String.Concat("DEVICE_COUNTER_", i + 1);
+
+                    sbIniData.AppendFormat("{0}_{1}_NAME={2}\r\n", counterName, counter.Language, counter.Name);
+                    if (null != counter.Help)
+                    {
+                        sbIniData.AppendFormat("{0}_{1}_HELP={2}\r\n", counterName, counter.Language, counter.Help);
+                    }
+
+                    symbolConstantsCounter += 2;
+                    sbSymbolicConstants.AppendFormat("#define {0}    {1}\r\n", counterName, symbolConstantsCounter);
+
+                    sbCounterNames.Append(UtilCompiler.FindPropertyBrackets.Replace(counter.Name, this.EscapeProperties));
+                    sbCounterNames.Append("[~]");
+                    sbCounterTypes.Append(counter.Type);
+                    sbCounterTypes.Append("[~]");
+                }
+
+                sbSymbolicConstants.AppendFormat("#define LAST_{0}_COUNTER_OFFSET    {1}\r\n", objectName, symbolConstantsCounter);
+
+                // Add the calculated INI and H strings to the PerformanceCategory table.
+                section.AddSymbol(new PerformanceCategorySymbol(sourceLineNumbers, id)
+                {
+                    ComponentRef = componentId,
+                    Name = name,
+                    IniData = sbIniData.ToString(),
+                    ConstantData = sbSymbolicConstants.ToString(),
+                });
+
+                // Set up the application's performance key.
+                var escapedName = UtilCompiler.FindPropertyBrackets.Replace(name, this.EscapeProperties);
+                var linkageKey = String.Format(@"SYSTEM\CurrentControlSet\Services\{0}\Linkage", escapedName);
+                var performanceKey = String.Format(@"SYSTEM\CurrentControlSet\Services\{0}\Performance", escapedName);
+
+                this.ParseHelper.CreateRegistrySymbol(section, sourceLineNumbers, RegistryRootType.LocalMachine, linkageKey, "Export", escapedName, componentId, false);
+                this.ParseHelper.CreateRegistrySymbol(section, sourceLineNumbers, RegistryRootType.LocalMachine, performanceKey, "-", null, componentId, false);
+                this.ParseHelper.CreateRegistrySymbol(section, sourceLineNumbers, RegistryRootType.LocalMachine, performanceKey, "Library", library, componentId, false);
+                this.ParseHelper.CreateRegistrySymbol(section, sourceLineNumbers, RegistryRootType.LocalMachine, performanceKey, "Open", openEntryPoint, componentId, false);
+                this.ParseHelper.CreateRegistrySymbol(section, sourceLineNumbers, RegistryRootType.LocalMachine, performanceKey, "Collect", collectEntryPoint, componentId, false);
+                this.ParseHelper.CreateRegistrySymbol(section, sourceLineNumbers, RegistryRootType.LocalMachine, performanceKey, "Close", closeEntryPoint, componentId, false);
+                this.ParseHelper.CreateRegistrySymbol(section, sourceLineNumbers, RegistryRootType.LocalMachine, performanceKey, "IsMultiInstance", YesNoType.Yes == multiInstance ? "#1" : "#0", componentId, false);
+                this.ParseHelper.CreateRegistrySymbol(section, sourceLineNumbers, RegistryRootType.LocalMachine, performanceKey, "Counter Names", sbCounterNames.ToString(), componentId, false);
+                this.ParseHelper.CreateRegistrySymbol(section, sourceLineNumbers, RegistryRootType.LocalMachine, performanceKey, "Counter Types", sbCounterTypes.ToString(), componentId, false);
+            }
+
+            this.ParseHelper.CreateCustomActionReference(sourceLineNumbers, section, "Wix4InstallPerfCounterData", this.Context.Platform, CustomActionPlatforms.X86 | CustomActionPlatforms.X64 | CustomActionPlatforms.ARM64);
+            this.ParseHelper.CreateCustomActionReference(sourceLineNumbers, section, "Wix4UninstallPerfCounterData", this.Context.Platform, CustomActionPlatforms.X86 | CustomActionPlatforms.X64 | CustomActionPlatforms.ARM64);
+        }
+
+        /// <summary>
+        /// Gets the performance counter language as a decimal number.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information about the owner element.</param>
+        /// <param name="attribute">The attribute containing the value to get.</param>
+        /// <returns>Numeric representation of the language as per WinNT.h.</returns>
+        private int GetPerformanceCounterLanguage(SourceLineNumber sourceLineNumbers, XAttribute attribute)
+        {
+            int language = 0;
+            if (String.Empty == attribute.Value)
+            {
+                this.Messaging.Write(ErrorMessages.IllegalEmptyAttributeValue(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName));
+            }
+            else
+            {
+                switch (attribute.Value)
+                {
+                    case "afrikaans":
+                        language = 0x36;
+                        break;
+                    case "albanian":
+                        language = 0x1c;
+                        break;
+                    case "arabic":
+                        language = 0x01;
+                        break;
+                    case "armenian":
+                        language = 0x2b;
+                        break;
+                    case "assamese":
+                        language = 0x4d;
+                        break;
+                    case "azeri":
+                        language = 0x2c;
+                        break;
+                    case "basque":
+                        language = 0x2d;
+                        break;
+                    case "belarusian":
+                        language = 0x23;
+                        break;
+                    case "bengali":
+                        language = 0x45;
+                        break;
+                    case "bulgarian":
+                        language = 0x02;
+                        break;
+                    case "catalan":
+                        language = 0x03;
+                        break;
+                    case "chinese":
+                        language = 0x04;
+                        break;
+                    case "croatian":
+                        language = 0x1a;
+                        break;
+                    case "czech":
+                        language = 0x05;
+                        break;
+                    case "danish":
+                        language = 0x06;
+                        break;
+                    case "divehi":
+                        language = 0x65;
+                        break;
+                    case "dutch":
+                        language = 0x13;
+                        break;
+                    case "piglatin":
+                    case "english":
+                        language = 0x09;
+                        break;
+                    case "estonian":
+                        language = 0x25;
+                        break;
+                    case "faeroese":
+                        language = 0x38;
+                        break;
+                    case "farsi":
+                        language = 0x29;
+                        break;
+                    case "finnish":
+                        language = 0x0b;
+                        break;
+                    case "french":
+                        language = 0x0c;
+                        break;
+                    case "galician":
+                        language = 0x56;
+                        break;
+                    case "georgian":
+                        language = 0x37;
+                        break;
+                    case "german":
+                        language = 0x07;
+                        break;
+                    case "greek":
+                        language = 0x08;
+                        break;
+                    case "gujarati":
+                        language = 0x47;
+                        break;
+                    case "hebrew":
+                        language = 0x0d;
+                        break;
+                    case "hindi":
+                        language = 0x39;
+                        break;
+                    case "hungarian":
+                        language = 0x0e;
+                        break;
+                    case "icelandic":
+                        language = 0x0f;
+                        break;
+                    case "indonesian":
+                        language = 0x21;
+                        break;
+                    case "italian":
+                        language = 0x10;
+                        break;
+                    case "japanese":
+                        language = 0x11;
+                        break;
+                    case "kannada":
+                        language = 0x4b;
+                        break;
+                    case "kashmiri":
+                        language = 0x60;
+                        break;
+                    case "kazak":
+                        language = 0x3f;
+                        break;
+                    case "konkani":
+                        language = 0x57;
+                        break;
+                    case "korean":
+                        language = 0x12;
+                        break;
+                    case "kyrgyz":
+                        language = 0x40;
+                        break;
+                    case "latvian":
+                        language = 0x26;
+                        break;
+                    case "lithuanian":
+                        language = 0x27;
+                        break;
+                    case "macedonian":
+                        language = 0x2f;
+                        break;
+                    case "malay":
+                        language = 0x3e;
+                        break;
+                    case "malayalam":
+                        language = 0x4c;
+                        break;
+                    case "manipuri":
+                        language = 0x58;
+                        break;
+                    case "marathi":
+                        language = 0x4e;
+                        break;
+                    case "mongolian":
+                        language = 0x50;
+                        break;
+                    case "nepali":
+                        language = 0x61;
+                        break;
+                    case "norwegian":
+                        language = 0x14;
+                        break;
+                    case "oriya":
+                        language = 0x48;
+                        break;
+                    case "polish":
+                        language = 0x15;
+                        break;
+                    case "portuguese":
+                        language = 0x16;
+                        break;
+                    case "punjabi":
+                        language = 0x46;
+                        break;
+                    case "romanian":
+                        language = 0x18;
+                        break;
+                    case "russian":
+                        language = 0x19;
+                        break;
+                    case "sanskrit":
+                        language = 0x4f;
+                        break;
+                    case "serbian":
+                        language = 0x1a;
+                        break;
+                    case "sindhi":
+                        language = 0x59;
+                        break;
+                    case "slovak":
+                        language = 0x1b;
+                        break;
+                    case "slovenian":
+                        language = 0x24;
+                        break;
+                    case "spanish":
+                        language = 0x0a;
+                        break;
+                    case "swahili":
+                        language = 0x41;
+                        break;
+                    case "swedish":
+                        language = 0x1d;
+                        break;
+                    case "syriac":
+                        language = 0x5a;
+                        break;
+                    case "tamil":
+                        language = 0x49;
+                        break;
+                    case "tatar":
+                        language = 0x44;
+                        break;
+                    case "telugu":
+                        language = 0x4a;
+                        break;
+                    case "thai":
+                        language = 0x1e;
+                        break;
+                    case "turkish":
+                        language = 0x1f;
+                        break;
+                    case "ukrainian":
+                        language = 0x22;
+                        break;
+                    case "urdu":
+                        language = 0x20;
+                        break;
+                    case "uzbek":
+                        language = 0x43;
+                        break;
+                    case "vietnamese":
+                        language = 0x2a;
+                        break;
+                    default:
+                        this.Messaging.Write(ErrorMessages.IllegalEmptyAttributeValue(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName));
+                        break;
+                }
+            }
+
+            return language;
+        }
+
+        /// <summary>
+        /// Parses a performance counter element.
+        /// </summary>
+        /// <param name="element">Element to parse.</param>
+        /// <param name="defaultLanguage">Default language for the performance counter.</param>
+        private ParsedPerformanceCounter ParsePerformanceCounterElement(Intermediate intermediate, IntermediateSection section, XElement element, int defaultLanguage)
+        {
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element);
+            ParsedPerformanceCounter parsedPerformanceCounter = null;
+            string name = null;
+            string help = null;
+            var type = System.Diagnostics.PerformanceCounterType.NumberOfItems32;
+            int language = defaultLanguage;
+
+            foreach (var attrib in element.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Help":
+                            help = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Name":
+                            name = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Type":
+                            type = this.GetPerformanceCounterType(sourceLineNumbers, attrib);
+                            break;
+                        case "Language":
+                            language = this.GetPerformanceCounterLanguage(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedAttribute(element, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib);
+                }
+            }
+
+            if (null == name)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "Name"));
+            }
+
+            if (null == help)
+            {
+                this.Messaging.Write(UtilWarnings.RequiredAttributeForWindowsXP(sourceLineNumbers, element.Name.LocalName, "Help"));
+            }
+
+            this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, element);
+
+            if (!this.Messaging.EncounteredError)
+            {
+                parsedPerformanceCounter = new ParsedPerformanceCounter(name, help, type, language);
+            }
+
+            return parsedPerformanceCounter;
+        }
+
+        /// <summary>
+        /// Gets the performance counter type.
+        /// </summary>
+        /// <param name="sourceLineNumbers">Source line information about the owner element.</param>
+        /// <param name="attribute">The attribute containing the value to get.</param>
+        /// <returns>Numeric representation of the language as per WinNT.h.</returns>
+        private System.Diagnostics.PerformanceCounterType GetPerformanceCounterType(SourceLineNumber sourceLineNumbers, XAttribute attribute)
+        {
+            var type = System.Diagnostics.PerformanceCounterType.NumberOfItems32;
+            if (String.Empty == attribute.Value)
+            {
+                this.Messaging.Write(ErrorMessages.IllegalEmptyAttributeValue(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName));
+            }
+            else
+            {
+                switch (attribute.Value)
+                {
+                    case "averageBase":
+                        type = System.Diagnostics.PerformanceCounterType.AverageBase;
+                        break;
+                    case "averageCount64":
+                        type = System.Diagnostics.PerformanceCounterType.AverageCount64;
+                        break;
+                    case "averageTimer32":
+                        type = System.Diagnostics.PerformanceCounterType.AverageTimer32;
+                        break;
+                    case "counterDelta32":
+                        type = System.Diagnostics.PerformanceCounterType.CounterDelta32;
+                        break;
+                    case "counterTimerInverse":
+                        type = System.Diagnostics.PerformanceCounterType.CounterTimerInverse;
+                        break;
+                    case "sampleFraction":
+                        type = System.Diagnostics.PerformanceCounterType.SampleFraction;
+                        break;
+                    case "timer100Ns":
+                        type = System.Diagnostics.PerformanceCounterType.Timer100Ns;
+                        break;
+                    case "counterTimer":
+                        type = System.Diagnostics.PerformanceCounterType.CounterTimer;
+                        break;
+                    case "rawFraction":
+                        type = System.Diagnostics.PerformanceCounterType.RawFraction;
+                        break;
+                    case "timer100NsInverse":
+                        type = System.Diagnostics.PerformanceCounterType.Timer100NsInverse;
+                        break;
+                    case "counterMultiTimer":
+                        type = System.Diagnostics.PerformanceCounterType.CounterMultiTimer;
+                        break;
+                    case "counterMultiTimer100Ns":
+                        type = System.Diagnostics.PerformanceCounterType.CounterMultiTimer100Ns;
+                        break;
+                    case "counterMultiTimerInverse":
+                        type = System.Diagnostics.PerformanceCounterType.CounterMultiTimerInverse;
+                        break;
+                    case "counterMultiTimer100NsInverse":
+                        type = System.Diagnostics.PerformanceCounterType.CounterMultiTimer100NsInverse;
+                        break;
+                    case "elapsedTime":
+                        type = System.Diagnostics.PerformanceCounterType.ElapsedTime;
+                        break;
+                    case "sampleBase":
+                        type = System.Diagnostics.PerformanceCounterType.SampleBase;
+                        break;
+                    case "rawBase":
+                        type = System.Diagnostics.PerformanceCounterType.RawBase;
+                        break;
+                    case "counterMultiBase":
+                        type = System.Diagnostics.PerformanceCounterType.CounterMultiBase;
+                        break;
+                    case "rateOfCountsPerSecond64":
+                        type = System.Diagnostics.PerformanceCounterType.RateOfCountsPerSecond64;
+                        break;
+                    case "rateOfCountsPerSecond32":
+                        type = System.Diagnostics.PerformanceCounterType.RateOfCountsPerSecond32;
+                        break;
+                    case "countPerTimeInterval64":
+                        type = System.Diagnostics.PerformanceCounterType.CountPerTimeInterval64;
+                        break;
+                    case "countPerTimeInterval32":
+                        type = System.Diagnostics.PerformanceCounterType.CountPerTimeInterval32;
+                        break;
+                    case "sampleCounter":
+                        type = System.Diagnostics.PerformanceCounterType.SampleCounter;
+                        break;
+                    case "counterDelta64":
+                        type = System.Diagnostics.PerformanceCounterType.CounterDelta64;
+                        break;
+                    case "numberOfItems64":
+                        type = System.Diagnostics.PerformanceCounterType.NumberOfItems64;
+                        break;
+                    case "numberOfItems32":
+                        type = System.Diagnostics.PerformanceCounterType.NumberOfItems32;
+                        break;
+                    case "numberOfItemsHEX64":
+                        type = System.Diagnostics.PerformanceCounterType.NumberOfItemsHEX64;
+                        break;
+                    case "numberOfItemsHEX32":
+                        type = System.Diagnostics.PerformanceCounterType.NumberOfItemsHEX32;
+                        break;
+                    default:
+                        this.Messaging.Write(ErrorMessages.IllegalEmptyAttributeValue(sourceLineNumbers, attribute.Parent.Name.LocalName, attribute.Name.LocalName));
+                        break;
+                }
+            }
+
+            return type;
+        }
+
+        /// <summary>
+        /// Parses a perf counter element.
+        /// </summary>
+        /// <param name="element">Element to parse.</param>
+        /// <param name="componentId">Identifier of parent component.</param>
+        /// <param name="fileId">Identifier of referenced file.</param>
+        private void ParsePerfCounterElement(Intermediate intermediate, IntermediateSection section, XElement element, string componentId, string fileId)
+        {
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element);
+            string name = null;
+
+            this.Messaging.Write(UtilWarnings.DeprecatedPerfCounterElement(sourceLineNumbers));
+
+            foreach (var attrib in element.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Name":
+                            name = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedAttribute(element, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib);
+                }
+            }
+
+            if (null == name)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "Name"));
+            }
+
+            this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, element);
+
+            if (!this.Messaging.EncounteredError)
+            {
+                section.AddSymbol(new PerfmonSymbol(sourceLineNumbers)
+                {
+                    ComponentRef = componentId,
+                    File = $"[#{fileId}]",
+                    Name = name,
+                });
+            }
+
+            this.ParseHelper.CreateCustomActionReference(sourceLineNumbers, section, "Wix4ConfigurePerfmonInstall", this.Context.Platform, CustomActionPlatforms.X86 | CustomActionPlatforms.X64 | CustomActionPlatforms.ARM64);
+            this.ParseHelper.CreateCustomActionReference(sourceLineNumbers, section, "Wix4ConfigurePerfmonUninstall", this.Context.Platform, CustomActionPlatforms.X86 | CustomActionPlatforms.X64 | CustomActionPlatforms.ARM64);
+        }
+
+
+        /// <summary>
+        /// Parses a perf manifest element.
+        /// </summary>
+        /// <param name="element">Element to parse.</param>
+        /// <param name="componentId">Identifier of parent component.</param>
+        /// <param name="fileId">Identifier of referenced file.</param>
+        private void ParsePerfCounterManifestElement(Intermediate intermediate, IntermediateSection section, XElement element, string componentId, string fileId)
+        {
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element);
+            string resourceFileDirectory = null;
+
+            foreach (var attrib in element.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "ResourceFileDirectory":
+                            resourceFileDirectory = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedAttribute(element, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib);
+                }
+            }
+
+            this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, element);
+
+            if (!this.Messaging.EncounteredError)
+            {
+                section.AddSymbol(new PerfmonManifestSymbol(sourceLineNumbers)
+                {
+                    ComponentRef = componentId,
+                    File = $"[#{fileId}]",
+                    ResourceFileDirectory = resourceFileDirectory,
+                });
+            }
+
+            this.ParseHelper.CreateCustomActionReference(sourceLineNumbers, section, "Wix4ConfigurePerfmonManifestRegister", this.Context.Platform, CustomActionPlatforms.X86 | CustomActionPlatforms.X64 | CustomActionPlatforms.ARM64);
+            this.ParseHelper.CreateCustomActionReference(sourceLineNumbers, section, "Wix4ConfigurePerfmonManifestUnregister", this.Context.Platform, CustomActionPlatforms.X86 | CustomActionPlatforms.X64 | CustomActionPlatforms.ARM64);
+        }
+
+        /// <summary>
+        /// Parses a format files element.
+        /// </summary>
+        /// <param name="element">Element to parse.</param>
+        /// <param name="fileId">Identifier of referenced file.</param>
+        /// <param name="win64">Flag to determine whether the component is 64-bit.</param>
+        private void ParseFormatFileElement(Intermediate intermediate, IntermediateSection section, XElement element, string fileId, bool win64)
+        {
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element);
+            string binaryId = null;
+
+            foreach (var attrib in element.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "BinaryRef":
+                            binaryId = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedAttribute(element, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib);
+                }
+            }
+
+            this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, element);
+
+            if (null == binaryId)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "BinaryRef"));
+            }
+
+            if (!this.Messaging.EncounteredError)
+            {
+                this.ParseHelper.CreateCustomActionReference(sourceLineNumbers, section, "Wix4SchedFormatFiles", this.Context.Platform, CustomActionPlatforms.X86 | CustomActionPlatforms.X64 | CustomActionPlatforms.ARM64);
+
+                section.AddSymbol(new WixFormatFilesSymbol(sourceLineNumbers)
+                {
+                    BinaryRef = binaryId,
+                    FileRef = fileId,
+                });
+
+                this.ParseHelper.CreateSimpleReference(section, sourceLineNumbers, SymbolDefinitions.Binary, binaryId);
+            }
+        }
+
+        /// <summary>
+        /// Parses a event manifest element.
+        /// </summary>
+        /// <param name="element">Element to parse.</param>
+        /// <param name="componentId">Identifier of parent component.</param>
+        /// <param name="fileId">Identifier of referenced file.</param>
+        private void ParseEventManifestElement(Intermediate intermediate, IntermediateSection section, XElement element, string componentId, string fileId)
+        {
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element);
+            string messageFile = null;
+            string resourceFile = null;
+            string parameterFile = null;
+
+            foreach (var attrib in element.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "MessageFile":
+                            messageFile = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ResourceFile":
+                            resourceFile = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ParameterFile":
+                            parameterFile = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedAttribute(element, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib);
+                }
+            }
+
+            this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, element);
+
+            if (!this.Messaging.EncounteredError)
+            {
+                section.AddSymbol(new EventManifestSymbol(sourceLineNumbers)
+                {
+                    ComponentRef = componentId,
+                    File = $"[#{fileId}]",
+                });
+
+                if (null != messageFile)
+                {
+                    section.AddSymbol(new XmlFileSymbol(sourceLineNumbers, new Identifier(AccessModifier.Section, $"Config_{fileId}MessageFile"))
+                    {
+                        File = $"[#{fileId}]",
+                        ElementPath = "/*/*/*/*[\\[]@messageFileName[\\]]",
+                        Name = "messageFileName",
+                        Value = messageFile,
+                        Flags = 4 | 0x00001000,  //bulk write | preserve modified date
+                        ComponentRef = componentId,
+                    });
+                }
+                if (null != parameterFile)
+                {
+                    section.AddSymbol(new XmlFileSymbol(sourceLineNumbers, new Identifier(AccessModifier.Section, $"Config_{fileId}ParameterFile"))
+                    {
+                        File = $"[#{fileId}]",
+                        ElementPath = "/*/*/*/*[\\[]@parameterFileName[\\]]",
+                        Name = "parameterFileName",
+                        Value = parameterFile,
+                        Flags = 4 | 0x00001000,  //bulk write | preserve modified date
+                        ComponentRef = componentId,
+                    });
+                }
+                if (null != resourceFile)
+                {
+                    section.AddSymbol(new XmlFileSymbol(sourceLineNumbers, new Identifier(AccessModifier.Section, $"Config_{fileId}ResourceFile"))
+                    {
+                        File = $"[#{fileId}]",
+                        ElementPath = "/*/*/*/*[\\[]@resourceFileName[\\]]",
+                        Name = "resourceFileName",
+                        Value = resourceFile,
+                        Flags = 4 | 0x00001000,  //bulk write | preserve modified date
+                        ComponentRef = componentId,
+                    });
+                }
+
+            }
+
+            this.ParseHelper.CreateCustomActionReference(sourceLineNumbers, section, "Wix4ConfigureEventManifestRegister", this.Context.Platform, CustomActionPlatforms.X86 | CustomActionPlatforms.X64 | CustomActionPlatforms.ARM64);
+            this.ParseHelper.CreateCustomActionReference(sourceLineNumbers, section, "Wix4ConfigureEventManifestUnregister", this.Context.Platform, CustomActionPlatforms.X86 | CustomActionPlatforms.X64 | CustomActionPlatforms.ARM64);
+
+            if (null != messageFile || null != parameterFile || null != resourceFile)
+            {
+                this.AddReferenceToSchedXmlFile(sourceLineNumbers, section);
+            }
+        }
+
+        /// <summary>
+        /// Parses a PermissionEx element.
+        /// </summary>
+        /// <param name="element">Element to parse.</param>
+        /// <param name="objectId">Identifier of object to be secured.</param>
+        /// <param name="componentId">Identifier of component, used to determine install state.</param>
+        /// <param name="win64">Flag to determine whether the component is 64-bit.</param>
+        /// <param name="tableName">Name of table that contains objectId.</param>
+        private void ParsePermissionExElement(Intermediate intermediate, IntermediateSection section, XElement element, string objectId, string componentId, bool win64, string tableName)
+        {
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element);
+            var bits = new BitArray(32);
+            string domain = null;
+            string[] specialPermissions = null;
+            string user = null;
+            var attributes = WixPermissionExAttributes.Inheritable; // default to inheritable.
+
+            var permissionType = PermissionType.SecureObjects;
+
+            switch (tableName)
+            {
+                case "CreateFolder":
+                    specialPermissions = UtilConstants.FolderPermissions;
+                    break;
+                case "File":
+                    specialPermissions = UtilConstants.FilePermissions;
+                    break;
+                case "Registry":
+                    specialPermissions = UtilConstants.RegistryPermissions;
+                    if (String.IsNullOrEmpty(objectId))
+                    {
+                        this.Messaging.Write(UtilErrors.InvalidRegistryObject(sourceLineNumbers, element.Parent.Name.LocalName));
+                    }
+                    break;
+                case "ServiceInstall":
+                    specialPermissions = UtilConstants.ServicePermissions;
+                    permissionType = PermissionType.SecureObjects;
+                    break;
+                default:
+                    this.ParseHelper.UnexpectedElement(element.Parent, element);
+                    break;
+            }
+
+            foreach (var attrib in element.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Domain":
+                            if (PermissionType.FileSharePermissions == permissionType)
+                            {
+                                this.Messaging.Write(ErrorMessages.IllegalAttributeWhenNested(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName, element.Parent.Name.LocalName));
+                            }
+                            domain = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Inheritable":
+                            if (this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib) == YesNoType.No)
+                            {
+                                attributes &= ~WixPermissionExAttributes.Inheritable;
+                            }
+                            break;
+                        case "User":
+                            user = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            var attribValue = this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            if (!this.TrySetBitFromName(UtilConstants.StandardPermissions, attrib.Name.LocalName, attribValue, bits, 16))
+                            {
+                                if (!this.TrySetBitFromName(UtilConstants.GenericPermissions, attrib.Name.LocalName, attribValue, bits, 28))
+                                {
+                                    if (!this.TrySetBitFromName(specialPermissions, attrib.Name.LocalName, attribValue, bits, 0))
+                                    {
+                                        this.ParseHelper.UnexpectedAttribute(element, attrib);
+                                        break;
+                                    }
+                                }
+                            }
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib);
+                }
+            }
+
+            var permission = this.CreateIntegerFromBitArray(bits);
+
+            if (null == user)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "User"));
+            }
+
+            if (Int32.MinValue == permission) // just GENERIC_READ, which is MSI_NULL
+            {
+                this.Messaging.Write(ErrorMessages.GenericReadNotAllowed(sourceLineNumbers));
+            }
+
+            this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, element);
+
+            if (!this.Messaging.EncounteredError)
+            {
+                this.ParseHelper.CreateCustomActionReference(sourceLineNumbers, section, "Wix4SchedSecureObjects", this.Context.Platform, CustomActionPlatforms.X86 | CustomActionPlatforms.X64 | CustomActionPlatforms.ARM64);
+
+                var id = this.ParseHelper.CreateIdentifier("sec", objectId, tableName, domain, user);
+                section.AddSymbol(new SecureObjectsSymbol(sourceLineNumbers, id)
+                {
+                    SecureObject = objectId,
+                    Table = tableName,
+                    Domain = domain,
+                    User = user,
+                    Attributes = attributes,
+                    Permission = permission,
+                    ComponentRef = componentId,
+                });
+            }
+        }
+
+        /// <summary>
+        /// Parses a ProductSearch element.
+        /// </summary>
+        /// <param name="element">Element to parse.</param>
+        private void ParseProductSearchElement(Intermediate intermediate, IntermediateSection section, XElement element)
+        {
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element);
+            Identifier id = null;
+            string variable = null;
+            string condition = null;
+            string after = null;
+            string productCode = null;
+            string upgradeCode = null;
+            var attributes = WixProductSearchAttributes.Version;
+
+            foreach (var attrib in element.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                        case "Variable":
+                        case "Condition":
+                        case "After":
+                            this.ParseCommonSearchAttributes(sourceLineNumbers, attrib, ref id, ref variable, ref condition, ref after);
+                            break;
+                        case "ProductCode":
+                            productCode = this.ParseHelper.GetAttributeGuidValue(sourceLineNumbers, attrib, false);
+                            break;
+                        case "UpgradeCode":
+                            upgradeCode = this.ParseHelper.GetAttributeGuidValue(sourceLineNumbers, attrib, false);
+                            break;
+                        case "Result":
+                            var result = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            switch (result)
+                            {
+                                case "version":
+                                    attributes = WixProductSearchAttributes.Version;
+                                    break;
+                                case "language":
+                                    attributes = WixProductSearchAttributes.Language;
+                                    break;
+                                case "state":
+                                    attributes = WixProductSearchAttributes.State;
+                                    break;
+                                case "assignment":
+                                    attributes = WixProductSearchAttributes.Assignment;
+                                    break;
+                                default:
+                                    this.Messaging.Write(ErrorMessages.IllegalAttributeValue(sourceLineNumbers, attrib.Parent.Name.LocalName, attrib.Name.LocalName, result, "version", "language", "state", "assignment"));
+                                    break;
+                            }
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedAttribute(element, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib);
+                }
+            }
+
+            if (null == upgradeCode && null == productCode)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "ProductCode", "UpgradeCode", true));
+            }
+
+            if (null != upgradeCode && null != productCode)
+            {
+                this.Messaging.Write(ErrorMessages.IllegalAttributeWithOtherAttribute(sourceLineNumbers, element.Name.LocalName, "UpgradeCode", "ProductCode"));
+            }
+
+            if (null == id)
+            {
+                id = this.ParseHelper.CreateIdentifier("wps", variable, condition, after, (productCode == null ? upgradeCode : productCode), attributes.ToString());
+            }
+
+            this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, element);
+
+            this.ParseHelper.CreateWixSearchSymbol(section, sourceLineNumbers, element.Name.LocalName, id, variable, condition, after, null);
+
+            if (!this.Messaging.EncounteredError)
+            {
+                // set an additional flag if this is an upgrade code
+                if (null != upgradeCode)
+                {
+                    attributes |= WixProductSearchAttributes.UpgradeCode;
+                }
+
+                section.AddSymbol(new WixProductSearchSymbol(sourceLineNumbers, id)
+                {
+                    Guid = productCode ?? upgradeCode,
+                    Attributes = attributes,
+                });
+            }
+        }
+
+        /// <summary>
+        /// Parses a RegistrySearch element.
+        /// </summary>
+        /// <param name="element">Element to parse.</param>
+        private void ParseRegistrySearchElement(Intermediate intermediate, IntermediateSection section, XElement element)
+        {
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element);
+            Identifier id = null;
+            string variable = null;
+            string condition = null;
+            string after = null;
+            RegistryRootType? root = null;
+            string key = null;
+            string value = null;
+            var expand = YesNoType.NotSet;
+            var win64 = this.Context.IsCurrentPlatform64Bit;
+            var attributes = WixRegistrySearchAttributes.Raw | WixRegistrySearchAttributes.WantValue;
+
+            foreach (var attrib in element.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                        case "Variable":
+                        case "Condition":
+                        case "After":
+                            this.ParseCommonSearchAttributes(sourceLineNumbers, attrib, ref id, ref variable, ref condition, ref after);
+                            break;
+                        case "Bitness":
+                            var bitnessValue = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            switch (bitnessValue)
+                            {
+                            case "always32":
+                                win64 = false;
+                                break;
+                            case "always64":
+                                win64 = true;
+                                break;
+                            case "default":
+                            case "":
+                                break;
+                            default:
+                                this.Messaging.Write(ErrorMessages.IllegalAttributeValue(sourceLineNumbers, attrib.Name.LocalName, attrib.Name.LocalName, bitnessValue, "default", "always32", "always64"));
+                                break;
+                            }
+                            break;
+                        case "Root":
+                            root = this.ParseHelper.GetAttributeRegistryRootValue(sourceLineNumbers, attrib, false);
+                            break;
+                        case "Key":
+                            key = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Value":
+                            value = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ExpandEnvironmentVariables":
+                            expand = this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Format":
+                            string format = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            switch (format)
+                            {
+                                case "raw":
+                                    attributes |= WixRegistrySearchAttributes.Raw;
+                                    break;
+                                case "compatible":
+                                    attributes |= WixRegistrySearchAttributes.Compatible;
+                                    break;
+                                default:
+                                    this.Messaging.Write(ErrorMessages.IllegalAttributeValue(sourceLineNumbers, attrib.Parent.Name.LocalName, attrib.Name.LocalName, format, "raw", "compatible"));
+                                    break;
+                            }
+                            break;
+                        case "Result":
+                            var result = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            switch (result)
+                            {
+                                case "exists":
+                                    attributes |= WixRegistrySearchAttributes.WantExists;
+                                    break;
+                                case "value":
+                                    attributes |= WixRegistrySearchAttributes.WantValue;
+                                    break;
+                                default:
+                                    this.Messaging.Write(ErrorMessages.IllegalAttributeValue(sourceLineNumbers, attrib.Parent.Name.LocalName, attrib.Name.LocalName, result, "exists", "value"));
+                                    break;
+                            }
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedAttribute(element, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib);
+                }
+            }
+
+            if (!root.HasValue)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "Root"));
+            }
+
+            if (null == key)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "Key"));
+            }
+
+            if (null == id)
+            {
+                id = this.ParseHelper.CreateIdentifier("wrs", variable, condition, after, root.ToString(), key, value, attributes.ToString());
+            }
+
+            if (expand == YesNoType.Yes)
+            {
+                if (0 != (attributes & WixRegistrySearchAttributes.WantExists))
+                {
+                    this.Messaging.Write(ErrorMessages.IllegalAttributeValueWithOtherAttribute(sourceLineNumbers, element.Name.LocalName, "ExpandEnvironmentVariables", expand.ToString(), "Result", "exists"));
+                }
+
+                attributes |= WixRegistrySearchAttributes.ExpandEnvironmentVariables;
+            }
+
+            if (win64)
+            {
+                attributes |= WixRegistrySearchAttributes.Win64;
+            }
+
+            this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, element);
+
+            this.ParseHelper.CreateWixSearchSymbol(section, sourceLineNumbers, element.Name.LocalName, id, variable, condition, after, null);
+
+            if (!this.Messaging.EncounteredError)
+            {
+                section.AddSymbol(new WixRegistrySearchSymbol(sourceLineNumbers, id)
+                {
+                    Root = root.Value,
+                    Key = key,
+                    Value = value,
+                    Attributes = attributes,
+                });
+            }
+        }
+
+        /// <summary>
+        /// Parses a RemoveFolderEx element.
+        /// </summary>
+        /// <param name="element">Element to parse.</param>
+        /// <param name="componentId">Identifier of parent component.</param>
+        private void ParseRemoveFolderExElement(Intermediate intermediate, IntermediateSection section, XElement element, string componentId)
+        {
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element);
+            Identifier id = null;
+            var mode = WixRemoveFolderExInstallMode.Uninstall;
+            string property = null;
+            string condition = null;
+
+            foreach (var attrib in element.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Condition":
+                            condition = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Id":
+                            id = this.ParseHelper.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "On":
+                            var onValue = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            if (onValue.Length == 0)
+                            {
+                            }
+                            else
+                            {
+                                switch (onValue)
+                                {
+                                    case "install":
+                                        mode = WixRemoveFolderExInstallMode.Install;
+                                        break;
+                                    case "uninstall":
+                                        mode = WixRemoveFolderExInstallMode.Uninstall;
+                                        break;
+                                    case "both":
+                                        mode = WixRemoveFolderExInstallMode.Both;
+                                        break;
+                                    default:
+                                        this.Messaging.Write(ErrorMessages.IllegalAttributeValue(sourceLineNumbers, element.Name.LocalName, "On", onValue, "install", "uninstall", "both"));
+                                        break;
+                                }
+                            }
+                            break;
+                        case "Property":
+                            property = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedAttribute(element, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib);
+                }
+            }
+
+            if (String.IsNullOrEmpty(property))
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "Property"));
+            }
+
+            if (id == null)
+            {
+                id = this.ParseHelper.CreateIdentifier("wrf", componentId, property, mode.ToString());
+            }
+
+            this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, element);
+
+            if (!this.Messaging.EncounteredError)
+            {
+                this.ParseHelper.CreateCustomActionReference(sourceLineNumbers, section, "Wix4RemoveFoldersEx", this.Context.Platform, CustomActionPlatforms.X86 | CustomActionPlatforms.X64 | CustomActionPlatforms.ARM64);
+
+                section.AddSymbol(new WixRemoveFolderExSymbol(sourceLineNumbers, id)
+                {
+                    ComponentRef = componentId,
+                    Property = property,
+                    InstallMode = mode,
+                    Condition = condition
+                });
+
+                this.ParseHelper.EnsureTable(section, sourceLineNumbers, "RemoveFile");
+            }
+        }
+
+        /// <summary>
+        /// Parses a RemoveRegistryKeyEx element.
+        /// </summary>
+        /// <param name="node">Element to parse.</param>
+        /// <param name="componentId">Identifier of parent component.</param>
+        private void ParseRemoveRegistryKeyExElement(Intermediate intermediate, IntermediateSection section, XElement element, string componentId)
+        {
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element);
+            Identifier id = null;
+            var mode = WixRemoveRegistryKeyExInstallMode.Uninstall;
+            string condition = null;
+            RegistryRootType? root = null;
+            string key = null;
+
+            foreach (var attrib in element.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Condition":
+                            condition = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Id":
+                            id = this.ParseHelper.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "On":
+                            var actionValue = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            switch (actionValue)
+                            {
+                                case "":
+                                    break;
+                                case "install":
+                                    mode = WixRemoveRegistryKeyExInstallMode.Install;
+                                    break;
+                                case "uninstall":
+                                    mode = WixRemoveRegistryKeyExInstallMode.Uninstall;
+                                    break;
+                                default:
+                                    this.Messaging.Write(ErrorMessages.IllegalAttributeValue(sourceLineNumbers, element.Name.LocalName, "On", actionValue, "install", "uninstall"));
+                                    break;
+                            }
+                            break;
+                        case "Root":
+                            root = this.ParseHelper.GetAttributeRegistryRootValue(sourceLineNumbers, attrib, false);
+                            break;
+                        case "Key":
+                            key = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedAttribute(element, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib);
+                }
+            }
+
+            if (!root.HasValue)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "Root"));
+            }
+
+            if (key == null)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "Key"));
+            }
+
+            if (id == null)
+            {
+                id = this.ParseHelper.CreateIdentifier("rrx", componentId, condition, root.ToString(), key, mode.ToString());
+            }
+
+            this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, element);
+
+            if (!this.Messaging.EncounteredError)
+            {
+                this.ParseHelper.EnsureTable(section, sourceLineNumbers, "Registry");
+                this.ParseHelper.EnsureTable(section, sourceLineNumbers, "RemoveRegistry");
+                this.ParseHelper.CreateCustomActionReference(sourceLineNumbers, section, "Wix4RemoveRegistryKeysEx", this.Context.Platform, CustomActionPlatforms.X86 | CustomActionPlatforms.X64 | CustomActionPlatforms.ARM64);
+
+                section.AddSymbol(new WixRemoveRegistryKeyExSymbol(sourceLineNumbers, id)
+                {
+                    ComponentRef = componentId,
+                    Root = root.Value,
+                    Key = key,
+                    InstallMode = mode,
+                    Condition = condition
+                });
+            }
+        }
+
+        /// <summary>
+        /// Parses a RestartResource element.
+        /// </summary>
+        /// <param name="element">The element to parse.</param>
+        /// <param name="componentId">The identity of the parent component.</param>
+        private void ParseRestartResourceElement(Intermediate intermediate, IntermediateSection section, XElement element, string componentId)
+        {
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element);
+            Identifier id = null;
+            string resource = null;
+            WixRestartResourceAttributes? attributes = null;
+
+            foreach (var attrib in element.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.ParseHelper.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+
+                        case "Path":
+                            resource = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            attributes = WixRestartResourceAttributes.Filename;
+                            break;
+
+                        case "ProcessName":
+                            resource = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            attributes = WixRestartResourceAttributes.ProcessName;
+                            break;
+
+                        case "ServiceName":
+                            resource = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            attributes = WixRestartResourceAttributes.ServiceName;
+                            break;
+
+                        default:
+                            this.ParseHelper.UnexpectedAttribute(element, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib);
+                }
+            }
+
+            // Validate the attribute.
+            if (id == null)
+            {
+                id = this.ParseHelper.CreateIdentifier("wrr", componentId, resource, attributes.ToString());
+            }
+
+            if (!attributes.HasValue)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttributes(sourceLineNumbers, element.Name.LocalName, "Path", "ProcessName", "ServiceName"));
+            }
+
+            this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, element);
+
+            if (!this.Messaging.EncounteredError)
+            {
+                this.ParseHelper.CreateCustomActionReference(sourceLineNumbers, section, "Wix4RegisterRestartResources", this.Context.Platform, CustomActionPlatforms.X86 | CustomActionPlatforms.X64 | CustomActionPlatforms.ARM64);
+
+                section.AddSymbol(new WixRestartResourceSymbol(sourceLineNumbers, id)
+                {
+                    ComponentRef = componentId,
+                    Resource = resource,
+                    Attributes = attributes,
+                });
+            }
+        }
+
+        /// <summary>
+        /// Parses a service configuration element.
+        /// </summary>
+        /// <param name="element">Element to parse.</param>
+        /// <param name="componentId">Identifier of parent component.</param>
+        /// <param name="parentTableName">Name of parent element.</param>
+        /// <param name="parentTableServiceName">Optional name of service </param>
+        private void ParseServiceConfigElement(Intermediate intermediate, IntermediateSection section, XElement element, string componentId, string parentTableName, string parentTableServiceName)
+        {
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element);
+            string firstFailureActionType = null;
+            var newService = false;
+            string programCommandLine = null;
+            string rebootMessage = null;
+            var resetPeriod = CompilerConstants.IntegerNotSet;
+            var restartServiceDelay = CompilerConstants.IntegerNotSet;
+            string secondFailureActionType = null;
+            string serviceName = null;
+            string thirdFailureActionType = null;
+
+            foreach (var attrib in element.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "FirstFailureActionType":
+                            firstFailureActionType = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ProgramCommandLine":
+                            programCommandLine = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "RebootMessage":
+                            rebootMessage = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ResetPeriodInDays":
+                            resetPeriod = this.ParseHelper.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, Int32.MaxValue);
+                            break;
+                        case "RestartServiceDelayInSeconds":
+                            restartServiceDelay = this.ParseHelper.GetAttributeIntegerValue(sourceLineNumbers, attrib, 0, Int32.MaxValue);
+                            break;
+                        case "SecondFailureActionType":
+                            secondFailureActionType = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ServiceName":
+                            serviceName = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ThirdFailureActionType":
+                            thirdFailureActionType = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedAttribute(element, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib);
+                }
+            }
+
+            // if this element is a child of ServiceInstall then ignore the service name provided.
+            if ("ServiceInstall" == parentTableName)
+            {
+                // TODO: the ServiceName attribute should not be allowed in this case (the overwriting behavior may confuse users)
+                serviceName = parentTableServiceName;
+                newService = true;
+            }
+            else
+            {
+                // not a child of ServiceInstall, so ServiceName must have been provided
+                if (null == serviceName)
+                {
+                    this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "ServiceName"));
+                }
+            }
+
+            this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, element);
+
+            if (!this.Messaging.EncounteredError)
+            {
+                this.ParseHelper.CreateCustomActionReference(sourceLineNumbers, section, "Wix4SchedServiceConfig", this.Context.Platform, CustomActionPlatforms.X86 | CustomActionPlatforms.X64 | CustomActionPlatforms.ARM64);
+
+                section.AddSymbol(new ServiceConfigSymbol(sourceLineNumbers)
+                {
+                    ServiceName = serviceName,
+                    ComponentRef = componentId,
+                    NewService = newService ? 1 : 0,
+                    FirstFailureActionType = firstFailureActionType,
+                    SecondFailureActionType = secondFailureActionType,
+                    ThirdFailureActionType = thirdFailureActionType,
+                    ResetPeriodInDays = resetPeriod,
+                    RestartServiceDelayInSeconds = restartServiceDelay,
+                    ProgramCommandLine = programCommandLine,
+                    RebootMessage = rebootMessage,
+                });
+            }
+        }
+
+        /// <summary>
+        /// Parses a touch file element.
+        /// </summary>
+        /// <param name="element">Element to parse.</param>
+        /// <param name="componentId">Identifier of parent component.</param>
+        /// <param name="win64">Indicates whether the path is a 64-bit path.</param>
+        private void ParseTouchFileElement(Intermediate intermediate, IntermediateSection section, XElement element, string componentId, bool win64)
+        {
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element);
+            Identifier id = null;
+            string path = null;
+            var onInstall = YesNoType.NotSet;
+            var onReinstall = YesNoType.NotSet;
+            var onUninstall = YesNoType.NotSet;
+            var nonvital = YesNoType.NotSet;
+            int attributes = 0;
+
+            foreach (var attrib in element.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.ParseHelper.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Path":
+                            path = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "OnInstall":
+                            onInstall = this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "OnReinstall":
+                            onReinstall = this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "OnUninstall":
+                            onUninstall = this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Nonvital":
+                            nonvital = this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedAttribute(element, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib);
+                }
+            }
+
+            if (null == path)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "Path"));
+            }
+
+            // If none of the scheduling actions are set, default to touching on install and reinstall.
+            if (YesNoType.NotSet == onInstall && YesNoType.NotSet == onReinstall && YesNoType.NotSet == onUninstall)
+            {
+                onInstall = YesNoType.Yes;
+                onReinstall = YesNoType.Yes;
+            }
+
+            attributes |= YesNoType.Yes == onInstall ? 0x1 : 0;
+            attributes |= YesNoType.Yes == onReinstall ? 0x2 : 0;
+            attributes |= YesNoType.Yes == onUninstall ? 0x4 : 0;
+            attributes |= win64 ? 0x10 : 0;
+            attributes |= YesNoType.Yes == nonvital ? 0 : 0x20;
+
+            if (null == id)
+            {
+                id = this.ParseHelper.CreateIdentifier("tf", path, attributes.ToString());
+            }
+
+            this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, element);
+
+            if (!this.Messaging.EncounteredError)
+            {
+                section.AddSymbol(new WixTouchFileSymbol(sourceLineNumbers, id)
+                {
+                    ComponentRef = componentId,
+                    Path = path,
+                    Attributes = attributes,
+                });
+
+                this.ParseHelper.CreateCustomActionReference(sourceLineNumbers, section, "Wix4TouchFileDuringInstall", this.Context.Platform, CustomActionPlatforms.X86 | CustomActionPlatforms.X64 | CustomActionPlatforms.ARM64);
+            }
+        }
+
+        /// <summary>
+        /// Parses an user element.
+        /// </summary>
+        /// <param name="element">Element to parse.</param>
+        /// <param name="componentId">Optional identifier of parent component.</param>
+        private void ParseUserElement(Intermediate intermediate, IntermediateSection section, XElement element, string componentId)
+        {
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element);
+            Identifier id = null;
+            int attributes = 0;
+            string domain = null;
+            string name = null;
+            string password = null;
+
+            foreach (var attrib in element.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.ParseHelper.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "CanNotChangePassword":
+                            if (null == componentId)
+                            {
+                                this.Messaging.Write(UtilErrors.IllegalAttributeWithoutComponent(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName));
+                            }
+
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= UserPasswdCantChange;
+                            }
+                            break;
+                        case "CreateUser":
+                            if (null == componentId)
+                            {
+                                this.Messaging.Write(UtilErrors.IllegalAttributeWithoutComponent(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName));
+                            }
+
+                            if (YesNoType.No == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= UserDontCreateUser;
+                            }
+                            break;
+                        case "Disabled":
+                            if (null == componentId)
+                            {
+                                this.Messaging.Write(UtilErrors.IllegalAttributeWithoutComponent(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName));
+                            }
+
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= UserDisableAccount;
+                            }
+                            break;
+                        case "Domain":
+                            domain = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "FailIfExists":
+                            if (null == componentId)
+                            {
+                                this.Messaging.Write(UtilErrors.IllegalAttributeWithoutComponent(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName));
+                            }
+
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= UserFailIfExists;
+                            }
+                            break;
+                        case "LogonAsService":
+                            if (null == componentId)
+                            {
+                                this.Messaging.Write(UtilErrors.IllegalAttributeWithoutComponent(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName));
+                            }
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= UserLogonAsService;
+                            }
+                            break;
+                        case "LogonAsBatchJob":
+                            if (null == componentId)
+                            {
+                                this.Messaging.Write(UtilErrors.IllegalAttributeWithoutComponent(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName));
+                            }
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= UserLogonAsBatchJob;
+                            }
+                            break;
+                        case "Name":
+                            name = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Password":
+                            password = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "PasswordExpired":
+                            if (null == componentId)
+                            {
+                                this.Messaging.Write(UtilErrors.IllegalAttributeWithoutComponent(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName));
+                            }
+
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= UserPasswdChangeReqdOnLogin;
+                            }
+                            break;
+                        case "PasswordNeverExpires":
+                            if (null == componentId)
+                            {
+                                this.Messaging.Write(UtilErrors.IllegalAttributeWithoutComponent(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName));
+                            }
+
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= UserDontExpirePasswrd;
+                            }
+                            break;
+                        case "RemoveOnUninstall":
+                            if (null == componentId)
+                            {
+                                this.Messaging.Write(UtilErrors.IllegalAttributeWithoutComponent(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName));
+                            }
+
+                            if (YesNoType.No == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= UserDontRemoveOnUninstall;
+                            }
+                            break;
+                        case "UpdateIfExists":
+                            if (null == componentId)
+                            {
+                                this.Messaging.Write(UtilErrors.IllegalAttributeWithoutComponent(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName));
+                            }
+
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= UserUpdateIfExists;
+                            }
+                            break;
+                        case "Vital":
+                            if (null == componentId)
+                            {
+                                this.Messaging.Write(UtilErrors.IllegalAttributeWithoutComponent(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName));
+                            }
+
+                            if (YesNoType.No == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                attributes |= UserNonVital;
+                            }
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedAttribute(element, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                id = this.ParseHelper.CreateIdentifier("usr", componentId, name);
+            }
+
+            if (null == name)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "Name"));
+            }
+
+            foreach (var child in element.Elements())
+            {
+                if (this.Namespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "GroupRef":
+                            if (null == componentId)
+                            {
+                                var childSourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(child);
+                                this.Messaging.Write(UtilErrors.IllegalElementWithoutComponent(childSourceLineNumbers, child.Name.LocalName));
+                            }
+
+                            this.ParseGroupRefElement(intermediate, section, child, id.Id);
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedElement(element, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionElement(this.Context.Extensions, intermediate, section, element, child);
+                }
+            }
+
+            if (null != componentId)
+            {
+                this.ParseHelper.CreateCustomActionReference(sourceLineNumbers, section, "Wix4ConfigureUsers", this.Context.Platform, CustomActionPlatforms.X86 | CustomActionPlatforms.X64 | CustomActionPlatforms.ARM64);
+            }
+
+            if (!this.Messaging.EncounteredError)
+            {
+                section.AddSymbol(new UserSymbol(sourceLineNumbers, id)
+                {
+                    ComponentRef = componentId,
+                    Name = name,
+                    Domain = domain,
+                    Password = password,
+                    Attributes = attributes,
+                });
+            }
+        }
+
+        /// <summary>
+        /// Parses a XmlFile element.
+        /// </summary>
+        /// <param name="element">Element to parse.</param>
+        /// <param name="componentId">Identifier of parent component.</param>
+        private void ParseXmlFileElement(Intermediate intermediate, IntermediateSection section, XElement element, string componentId)
+        {
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element);
+            Identifier id = null;
+            string file = null;
+            string elementPath = null;
+            string name = null;
+            string value = null;
+            int sequence = -1;
+            int flags = 0;
+
+            foreach (var attrib in element.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Action":
+                            var actionValue = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            switch (actionValue)
+                            {
+                                case "createElement":
+                                    flags |= 0x00000001; // XMLFILE_CREATE_ELEMENT
+                                    break;
+                                case "deleteValue":
+                                    flags |= 0x00000002; // XMLFILE_DELETE_VALUE
+                                    break;
+                                case "bulkSetValue":
+                                    flags |= 0x00000004; // XMLFILE_BULKWRITE_VALUE
+                                    break;
+                                case "setValue":
+                                    // no flag for set value since it's the default
+                                    break;
+                                default:
+                                    this.Messaging.Write(ErrorMessages.IllegalAttributeValue(sourceLineNumbers, element.Name.LocalName, "Action", actionValue, "createElement", "deleteValue", "setValue", "bulkSetValue"));
+                                    break;
+                            }
+                            break;
+                        case "SelectionLanguage":
+                            string selectionLanguage = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            switch (selectionLanguage)
+                            {
+                                case "XPath":
+                                    flags |= 0x00000100; // XMLFILE_USE_XPATH
+                                    break;
+                                case "XSLPattern":
+                                    // no flag for since it's the default
+                                    break;
+                                default:
+                                    this.Messaging.Write(ErrorMessages.IllegalAttributeValue(sourceLineNumbers, element.Name.LocalName, "SelectionLanguage", selectionLanguage, "XPath", "XSLPattern"));
+                                    break;
+                            }
+                            break;
+                        case "Id":
+                            id = this.ParseHelper.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "File":
+                            file = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ElementPath":
+                            elementPath = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Name":
+                            name = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Permanent":
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                flags |= 0x00010000; // XMLFILE_DONT_UNINSTALL
+                            }
+                            break;
+                        case "Sequence":
+                            sequence = this.ParseHelper.GetAttributeIntegerValue(sourceLineNumbers, attrib, 1, Int16.MaxValue);
+                            break;
+                        case "Value":
+                            value = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "PreserveModifiedDate":
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                flags |= 0x00001000; // XMLFILE_PRESERVE_MODIFIED
+                            }
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedAttribute(element, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                id = this.ParseHelper.CreateIdentifier("uxf", componentId, file, elementPath, name);
+            }
+
+            if (null == file)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "File"));
+            }
+
+            if (null == elementPath)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "ElementPath"));
+            }
+
+            if ((0x00000001 /*XMLFILE_CREATE_ELEMENT*/ & flags) != 0 && null == name)
+            {
+                this.Messaging.Write(ErrorMessages.IllegalAttributeWithoutOtherAttributes(sourceLineNumbers, element.Name.LocalName, "Action", "Name"));
+            }
+
+            this.ParseHelper.ParseForExtensionElements(this.Context.Extensions, intermediate, section, element);
+
+            if (!this.Messaging.EncounteredError)
+            {
+                var symbol = section.AddSymbol(new XmlFileSymbol(sourceLineNumbers, id)
+                {
+                    File = file,
+                    ElementPath = elementPath,
+                    Name = name,
+                    Value = value,
+                    Flags = flags,
+                    ComponentRef = componentId,
+                });
+                if (-1 != sequence)
+                {
+                    symbol.Sequence = sequence;
+                }
+            }
+
+            this.AddReferenceToSchedXmlFile(sourceLineNumbers, section);
+        }
+
+        /// <summary>
+        /// Parses a XmlConfig element.
+        /// </summary>
+        /// <param name="element">Element to parse.</param>
+        /// <param name="componentId">Identifier of parent component.</param>
+        /// <param name="nested">Whether or not the element is nested.</param>
+        private void ParseXmlConfigElement(Intermediate intermediate, IntermediateSection section, XElement element, string componentId, bool nested)
+        {
+            var sourceLineNumbers = this.ParseHelper.GetSourceLineNumbers(element);
+            Identifier id = null;
+            string elementId = null;
+            string elementPath = null;
+            int flags = 0;
+            string file = null;
+            string name = null;
+            var sequence = CompilerConstants.IntegerNotSet;
+            string value = null;
+            string verifyPath = null;
+
+            foreach (var attrib in element.Attributes())
+            {
+                if (String.IsNullOrEmpty(attrib.Name.NamespaceName) || this.Namespace == attrib.Name.Namespace)
+                {
+                    switch (attrib.Name.LocalName)
+                    {
+                        case "Id":
+                            id = this.ParseHelper.GetAttributeIdentifier(sourceLineNumbers, attrib);
+                            break;
+                        case "Action":
+                            if (nested)
+                            {
+                                this.Messaging.Write(ErrorMessages.IllegalAttributeWhenNested(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName, element.Parent.Name.LocalName));
+                            }
+                            else
+                            {
+                                string actionValue = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                                switch (actionValue)
+                                {
+                                    case "create":
+                                        flags |= 0x10; // XMLCONFIG_CREATE
+                                        break;
+                                    case "delete":
+                                        flags |= 0x20; // XMLCONFIG_DELETE
+                                        break;
+                                    default:
+                                        this.Messaging.Write(ErrorMessages.IllegalAttributeValue(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName, actionValue, "create", "delete"));
+                                        break;
+                                }
+                            }
+                            break;
+                        case "ElementId":
+                            elementId = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "ElementPath":
+                            elementPath = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "File":
+                            file = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Name":
+                            name = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "Node":
+                            if (nested)
+                            {
+                                this.Messaging.Write(ErrorMessages.IllegalAttributeWhenNested(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName, element.Parent.Name.LocalName));
+                            }
+                            else
+                            {
+                                var nodeValue = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                                switch (nodeValue)
+                                {
+                                    case "element":
+                                        flags |= 0x1; // XMLCONFIG_ELEMENT
+                                        break;
+                                    case "value":
+                                        flags |= 0x2; // XMLCONFIG_VALUE
+                                        break;
+                                    case "document":
+                                        flags |= 0x4; // XMLCONFIG_DOCUMENT
+                                        break;
+                                    default:
+                                        this.Messaging.Write(ErrorMessages.IllegalAttributeValue(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName, nodeValue, "element", "value", "document"));
+                                        break;
+                                }
+                            }
+                            break;
+                        case "On":
+                            if (nested)
+                            {
+                                this.Messaging.Write(ErrorMessages.IllegalAttributeWhenNested(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName, element.Parent.Name.LocalName));
+                            }
+                            else
+                            {
+                                var onValue = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                                switch (onValue)
+                                {
+                                    case "install":
+                                        flags |= 0x100; // XMLCONFIG_INSTALL
+                                        break;
+                                    case "uninstall":
+                                        flags |= 0x200; // XMLCONFIG_UNINSTALL
+                                        break;
+                                    default:
+                                        this.Messaging.Write(ErrorMessages.IllegalAttributeValue(sourceLineNumbers, element.Name.LocalName, attrib.Name.LocalName, onValue, "install", "uninstall"));
+                                        break;
+                                }
+                            }
+                            break;
+                        case "PreserveModifiedDate":
+                            if (YesNoType.Yes == this.ParseHelper.GetAttributeYesNoValue(sourceLineNumbers, attrib))
+                            {
+                                flags |= 0x00001000; // XMLCONFIG_PRESERVE_MODIFIED
+                            }
+                            break;
+                        case "Sequence":
+                            sequence = this.ParseHelper.GetAttributeIntegerValue(sourceLineNumbers, attrib, 1, Int16.MaxValue);
+                            break;
+                        case "Value":
+                            value = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        case "VerifyPath":
+                            verifyPath = this.ParseHelper.GetAttributeValue(sourceLineNumbers, attrib);
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedAttribute(element, attrib);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionAttribute(this.Context.Extensions, intermediate, section, element, attrib);
+                }
+            }
+
+            if (null == id)
+            {
+                id = this.ParseHelper.CreateIdentifier("uxc", componentId, file, elementId, elementPath);
+            }
+
+            if (null == file)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttribute(sourceLineNumbers, element.Name.LocalName, "File"));
+            }
+
+            if (null == elementId && null == elementPath)
+            {
+                this.Messaging.Write(ErrorMessages.ExpectedAttributes(sourceLineNumbers, element.Name.LocalName, "ElementId", "ElementPath"));
+            }
+            else if (null != elementId)
+            {
+                if (null != elementPath)
+                {
+                    this.Messaging.Write(ErrorMessages.IllegalAttributeWithOtherAttribute(sourceLineNumbers, element.Name.LocalName, "ElementId", "ElementPath"));
+                }
+
+                if (0 != flags)
+                {
+                    this.Messaging.Write(ErrorMessages.IllegalAttributeWithOtherAttributes(sourceLineNumbers, element.Name.LocalName, "ElementId", "Action", "Node", "On"));
+                }
+
+                this.ParseHelper.CreateSimpleReference(section, sourceLineNumbers, UtilSymbolDefinitions.XmlConfig, elementId);
+            }
+
+            // find unexpected child elements
+            foreach (var child in element.Elements())
+            {
+                if (this.Namespace == child.Name.Namespace)
+                {
+                    switch (child.Name.LocalName)
+                    {
+                        case "XmlConfig":
+                            if (nested)
+                            {
+                                this.Messaging.Write(ErrorMessages.UnexpectedElement(sourceLineNumbers, element.Name.LocalName, child.Name.LocalName));
+                            }
+                            else
+                            {
+                                this.ParseXmlConfigElement(intermediate, section, child, componentId, true);
+                            }
+                            break;
+                        default:
+                            this.ParseHelper.UnexpectedElement(element, child);
+                            break;
+                    }
+                }
+                else
+                {
+                    this.ParseHelper.ParseExtensionElement(this.Context.Extensions, intermediate, section, element, child);
+                }
+            }
+
+            if (!this.Messaging.EncounteredError)
+            {
+                var symbol = section.AddSymbol(new XmlConfigSymbol(sourceLineNumbers, id)
+                {
+                    File = file,
+                    ElementId = elementId,
+                    ElementPath = elementPath,
+                    VerifyPath = verifyPath,
+                    Name = name,
+                    Value = value,
+                    Flags = flags,
+                    ComponentRef = componentId,
+                });
+
+                if (CompilerConstants.IntegerNotSet != sequence)
+                {
+                    symbol.Sequence = sequence;
+                }
+            }
+
+            this.ParseHelper.CreateCustomActionReference(sourceLineNumbers, section, "Wix4SchedXmlConfig", this.Context.Platform, CustomActionPlatforms.X86 | CustomActionPlatforms.X64 | CustomActionPlatforms.ARM64);
+        }
+
+        /// <summary>
+        /// Match evaluator to escape properties in a string.
+        /// </summary>
+        private string EscapeProperties(Match match)
+        {
+            string escape = null;
+            switch (match.Value)
+            {
+                case "[":
+                    escape = @"[\[]";
+                    break;
+                case "]":
+                    escape = @"[\]]";
+                    break;
+            }
+
+            return escape;
+        }
+
+        private 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");
+            }
+
+            var intArray = new int[1];
+            bits.CopyTo(intArray, 0);
+
+            return intArray[0];
+        }
+
+        private bool TrySetBitFromName(string[] attributeNames, string attributeName, YesNoType attributeValue, BitArray bits, int offset)
+        {
+            for (var i = 0; i < attributeNames.Length; i++)
+            {
+                if (attributeName.Equals(attributeNames[i], StringComparison.Ordinal))
+                {
+                    bits.Set(i + offset, YesNoType.Yes == attributeValue);
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        private void AddReferenceToSchedXmlFile(SourceLineNumber sourceLineNumbers, IntermediateSection section)
+        {
+            this.ParseHelper.CreateCustomActionReference(sourceLineNumbers, section, "Wix4SchedXmlFile", this.Context.Platform, CustomActionPlatforms.X86 | CustomActionPlatforms.X64 | CustomActionPlatforms.ARM64);
+        }
+
+        /// <summary>
+        /// Private class that stores the data from a parsed PerformanceCounter element.
+        /// </summary>
+        private class ParsedPerformanceCounter
+        {
+            internal ParsedPerformanceCounter(string name, string help, System.Diagnostics.PerformanceCounterType type, int language)
+            {
+                this.Name = name;
+                this.Help = help;
+                this.Type = (int)type;
+                this.Language = language.ToString("D3", CultureInfo.InvariantCulture);
+            }
+
+            internal string Name { get; }
+
+            internal string Help { get; }
+
+            internal int Type { get; }
+
+            internal string Language { get; }
+        }
+    }
+}
diff --git a/src/ext/Util/wixext/UtilConstants.cs b/src/ext/Util/wixext/UtilConstants.cs
new file mode 100644
index 00000000..28ff368f
--- /dev/null
+++ b/src/ext/Util/wixext/UtilConstants.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.Util
+{
+    /// <summary>
+    /// Constants used by Utility Extension.
+    /// </summary>
+    internal static class UtilConstants
+    {
+        internal static readonly string[] FilePermissions = { "Read", "Write", "Append", "ReadExtendedAttributes", "WriteExtendedAttributes", "Execute", null, "ReadAttributes", "WriteAttributes" };
+        internal static readonly string[] FolderPermissions = { "Read", "CreateFile", "CreateChild", "ReadExtendedAttributes", "WriteExtendedAttributes", "Traverse", "DeleteChild", "ReadAttributes", "WriteAttributes" };
+        internal static readonly string[] GenericPermissions = { "GenericAll", "GenericExecute", "GenericWrite", "GenericRead" };
+        internal static readonly string[] RegistryPermissions = { "Read", "Write", "CreateSubkeys", "EnumerateSubkeys", "Notify", "CreateLink" };
+        internal static readonly string[] ServicePermissions = { "ServiceQueryConfig", "ServiceChangeConfig", "ServiceQueryStatus", "ServiceEnumerateDependents", "ServiceStart", "ServiceStop", "ServicePauseContinue", "ServiceInterrogate", "ServiceUserDefinedControl" };
+        internal static readonly string[] StandardPermissions = { "Delete", "ReadPermission", "ChangePermission", "TakeOwnership", "Synchronize" };
+    }
+}
diff --git a/src/ext/Util/wixext/UtilDecompiler.cs b/src/ext/Util/wixext/UtilDecompiler.cs
new file mode 100644
index 00000000..9ef3390f
--- /dev/null
+++ b/src/ext/Util/wixext/UtilDecompiler.cs
@@ -0,0 +1,1543 @@
+// 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.Extensions
+{
+#if TODO_CONSIDER_DECOMPILER
+    using System;
+    using System.IO;
+    using System.Text;
+    using System.Collections;
+    using System.Diagnostics;
+    using System.Globalization;
+
+    using Util = WixToolset.Extensions.Serialize.Util;
+    using WixToolset.Data;
+    using WixToolset.Extensibility;
+    using Wix = WixToolset.Data.Serialize;
+
+    /// <summary>
+    /// The decompiler for the WiX Toolset Utility Extension.
+    /// </summary>
+    public sealed class UtilDecompiler : DecompilerExtension
+    {
+        /// <summary>
+        /// Creates a decompiler for Utility Extension.
+        /// </summary>
+        public UtilDecompiler()
+        {
+            this.TableDefinitions = UtilExtensionData.GetExtensionTableDefinitions();
+        }
+
+        /// <summary>
+        /// Get the extensions library to be removed.
+        /// </summary>
+        /// <param name="tableDefinitions">Table definitions for library.</param>
+        /// <returns>Library to remove from decompiled output.</returns>
+        public override Library GetLibraryToRemove(TableDefinitionCollection tableDefinitions)
+        {
+            return UtilExtensionData.GetExtensionLibrary(tableDefinitions);
+        }
+
+        /// <summary>
+        /// Called at the beginning of the decompilation of a database.
+        /// </summary>
+        /// <param name="tables">The collection of all tables.</param>
+        public override void Initialize(TableIndexedCollection tables)
+        {
+            this.CleanupSecureCustomProperties(tables);
+            this.CleanupInternetShortcutRemoveFileTables(tables);
+        }
+
+        /// <summary>
+        /// Decompile the SecureCustomProperties field to PropertyRefs for known extension properties.
+        /// </summary>
+        /// <remarks>
+        /// If we've referenced any of the suite or directory properties, add
+        /// a PropertyRef to refer to the Property (and associated custom action)
+        /// from the extension's library. Then remove the property from
+        /// SecureCustomExtensions property so later decompilation won't create
+        /// new Property elements.
+        /// </remarks>
+        /// <param name="tables">The collection of all tables.</param>
+        private void CleanupSecureCustomProperties(TableIndexedCollection tables)
+        {
+            Table propertyTable = tables["Property"];
+
+            if (null != propertyTable)
+            {
+                foreach (Row row in propertyTable.Rows)
+                {
+                    if ("SecureCustomProperties" == row[0].ToString())
+                    {
+                        StringBuilder remainingProperties = new StringBuilder();
+                        string[] secureCustomProperties = row[1].ToString().Split(';');
+                        foreach (string property in secureCustomProperties)
+                        {
+                            if (property.StartsWith("WIX_SUITE_", StringComparison.Ordinal) || property.StartsWith("WIX_DIR_", StringComparison.Ordinal)
+                                || property.StartsWith("WIX_ACCOUNT_", StringComparison.Ordinal))
+                            {
+                                Wix.PropertyRef propertyRef = new Wix.PropertyRef();
+                                propertyRef.Id = property;
+                                this.Core.RootElement.AddChild(propertyRef);
+                            }
+                            else
+                            {
+                                if (0 < remainingProperties.Length)
+                                {
+                                    remainingProperties.Append(";");
+                                }
+                                remainingProperties.Append(property);
+                            }
+                        }
+
+                        row[1] = remainingProperties.ToString();
+                        break;
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Remove RemoveFile rows that the InternetShortcut compiler extension adds for us.
+        /// </summary>
+        /// <param name="tables">The collection of all tables.</param>
+        private void CleanupInternetShortcutRemoveFileTables(TableIndexedCollection tables)
+        {
+            // index the WixInternetShortcut table
+            Table wixInternetShortcutTable = tables["WixInternetShortcut"];
+            Hashtable wixInternetShortcuts = new Hashtable();
+            if (null != wixInternetShortcutTable)
+            {
+                foreach (Row row in wixInternetShortcutTable.Rows)
+                {
+                    wixInternetShortcuts.Add(row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), row);
+                }
+            }
+
+            // remove the RemoveFile rows with primary keys that match the WixInternetShortcut table's
+            Table removeFileTable = tables["RemoveFile"];
+            if (null != removeFileTable)
+            {
+                for (int i = removeFileTable.Rows.Count - 1; 0 <= i; i--)
+                {
+                    if (null != wixInternetShortcuts[removeFileTable.Rows[i][0]])
+                    {
+                        removeFileTable.Rows.RemoveAt(i);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompiles an extension table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        public override void DecompileTable(Table table)
+        {
+            switch (table.Name)
+            {
+                case "WixCloseApplication":
+                    this.DecompileWixCloseApplicationTable(table);
+                    break;
+                case "WixRemoveFolderEx":
+                    this.DecompileWixRemoveFolderExTable(table);
+                    break;
+                case "WixRestartResource":
+                    this.DecompileWixRestartResourceTable(table);
+                    break;
+                case "FileShare":
+                    this.DecompileFileShareTable(table);
+                    break;
+                case "FileSharePermissions":
+                    this.DecompileFileSharePermissionsTable(table);
+                    break;
+                case "WixInternetShortcut":
+                    this.DecompileWixInternetShortcutTable(table);
+                    break;
+                case "Group":
+                    this.DecompileGroupTable(table);
+                    break;
+                case "Perfmon":
+                    this.DecompilePerfmonTable(table);
+                    break;
+                case "PerfmonManifest":
+                    this.DecompilePerfmonManifestTable(table);
+                    break;
+                case "EventManifest":
+                    this.DecompileEventManifestTable(table);
+                    break;
+                case "SecureObjects":
+                    this.DecompileSecureObjectsTable(table);
+                    break;
+                case "ServiceConfig":
+                    this.DecompileServiceConfigTable(table);
+                    break;
+                case "User":
+                    this.DecompileUserTable(table);
+                    break;
+                case "UserGroup":
+                    this.DecompileUserGroupTable(table);
+                    break;
+                case "XmlConfig":
+                    this.DecompileXmlConfigTable(table);
+                    break;
+                case "XmlFile":
+                    // XmlFile decompilation has been moved to FinalizeXmlFileTable function
+                    break;
+                default:
+                    base.DecompileTable(table);
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// Finalize decompilation.
+        /// </summary>
+        /// <param name="tables">The collection of all tables.</param>
+        public override void Finish(TableIndexedCollection tables)
+        {
+            this.FinalizePerfmonTable(tables);
+            this.FinalizePerfmonManifestTable(tables);
+            this.FinalizeSecureObjectsTable(tables);
+            this.FinalizeServiceConfigTable(tables);
+            this.FinalizeXmlConfigTable(tables);
+            this.FinalizeXmlFileTable(tables);
+            this.FinalizeEventManifestTable(tables);
+        }
+
+        /// <summary>
+        /// Decompile the WixCloseApplication table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileWixCloseApplicationTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Util.CloseApplication closeApplication = new Util.CloseApplication();
+
+                closeApplication.Id = (string)row[0];
+
+                closeApplication.Target = (string)row[1];
+
+                if (null != row[2])
+                {
+                    closeApplication.Description = (string)row[2];
+                }
+
+                if (null != row[3])
+                {
+                    closeApplication.Content = (string)row[3];
+                }
+
+                // set defaults
+                closeApplication.CloseMessage = Util.YesNoType.no;
+                closeApplication.RebootPrompt = Util.YesNoType.yes;
+                closeApplication.ElevatedCloseMessage = Util.YesNoType.no;
+
+                if (null != row[4])
+                {
+                    int attribute = (int)row[4];
+
+                    closeApplication.CloseMessage = (0x1 == (attribute & 0x1)) ? Util.YesNoType.yes : Util.YesNoType.no;
+                    closeApplication.RebootPrompt = (0x2 == (attribute & 0x2)) ? Util.YesNoType.yes : Util.YesNoType.no;
+                    closeApplication.ElevatedCloseMessage = (0x4 == (attribute & 0x4)) ? Util.YesNoType.yes : Util.YesNoType.no;
+                }
+
+                if (null != row[5])
+                {
+                    closeApplication.Sequence = (int)row[5];
+                }
+
+                if (null != row[6])
+                {
+                    closeApplication.Property = (string)row[6];
+                }
+
+                this.Core.RootElement.AddChild(closeApplication);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the WixRemoveFolderEx table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileWixRemoveFolderExTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                // Set the Id even if auto-generated previously.
+                Util.RemoveFolderEx removeFolder = new Util.RemoveFolderEx();
+                removeFolder.Id = (string)row[0];
+                removeFolder.Property = (string)row[2];
+
+                int installMode = (int)row[3];
+                switch ((UtilCompiler.WixRemoveFolderExOn)installMode)
+                {
+                    case UtilCompiler.WixRemoveFolderExOn.Install:
+                        removeFolder.On = Util.RemoveFolderEx.OnType.install;
+                        break;
+                      
+                    case UtilCompiler.WixRemoveFolderExOn.Uninstall:
+                        removeFolder.On = Util.RemoveFolderEx.OnType.uninstall;
+                        break;
+                      
+                    case UtilCompiler.WixRemoveFolderExOn.Both:
+                        removeFolder.On = Util.RemoveFolderEx.OnType.both;
+                        break;
+
+                    default:
+                        this.Core.OnMessage(WixWarnings.UnrepresentableColumnValue(row.SourceLineNumbers, table.Name, "InstallMode", installMode));
+                        break;
+                }
+
+                // Add to the appropriate Component or section element.
+                string componentId = (string)row[1];
+                Wix.Component component = (Wix.Component)this.Core.GetIndexedElement("Component", componentId);
+                if (null != component)
+                {
+                    component.AddChild(removeFolder);
+                }
+                else
+                {
+                    this.Core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", componentId, "Component"));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the WixRestartResource table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileWixRestartResourceTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                // Set the Id even if auto-generated previously.
+                Util.RestartResource restartResource = new Util.RestartResource();
+                restartResource.Id = (string)row[0];
+
+                // Determine the resource type and set accordingly.
+                string resource = (string)row[2];
+                int attributes = (int)row[3];
+                UtilCompiler.WixRestartResourceAttributes type = (UtilCompiler.WixRestartResourceAttributes)(attributes & (int)UtilCompiler.WixRestartResourceAttributes.TypeMask);
+
+                switch (type)
+                {
+                    case UtilCompiler.WixRestartResourceAttributes.Filename:
+                        restartResource.Path = resource;
+                        break;
+
+                    case UtilCompiler.WixRestartResourceAttributes.ProcessName:
+                        restartResource.ProcessName = resource;
+                        break;
+
+                    case UtilCompiler.WixRestartResourceAttributes.ServiceName:
+                        restartResource.ServiceName = resource;
+                        break;
+
+                    default:
+                        this.Core.OnMessage(WixWarnings.UnrepresentableColumnValue(row.SourceLineNumbers, table.Name, "Attributes", attributes));
+                        break;
+                }
+
+                // Add to the appropriate Component or section element.
+                string componentId = (string)row[1];
+                if (!String.IsNullOrEmpty(componentId))
+                {
+                    Wix.Component component = (Wix.Component)this.Core.GetIndexedElement("Component", componentId);
+                    if (null != component)
+                    {
+                        component.AddChild(restartResource);
+                    }
+                    else
+                    {
+                        this.Core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", componentId, "Component"));
+                    }
+                }
+                else
+                {
+                    this.Core.RootElement.AddChild(restartResource);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the FileShare table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileFileShareTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Util.FileShare fileShare = new Util.FileShare();
+
+                fileShare.Id = (string)row[0];
+
+                fileShare.Name = (string)row[1];
+
+                if (null != row[3])
+                {
+                    fileShare.Description = (string)row[3];
+                }
+
+                // the Directory_ column is set by the parent Component
+
+                // the User_ and Permissions columns are deprecated
+
+                Wix.Component component = (Wix.Component)this.Core.GetIndexedElement("Component", (string)row[2]);
+                if (null != component)
+                {
+                    component.AddChild(fileShare);
+                }
+                else
+                {
+                    this.Core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", (string)row[2], "Component"));
+                }
+                this.Core.IndexElement(row, fileShare);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the FileSharePermissions table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileFileSharePermissionsTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Util.FileSharePermission fileSharePermission = new Util.FileSharePermission();
+
+                fileSharePermission.User = (string)row[1];
+
+                string[] specialPermissions = UtilConstants.FolderPermissions;
+                int permissions = (int)row[2];
+                for (int i = 0; i < 32; i++)
+                {
+                    if (0 != ((permissions >> i) & 1))
+                    {
+                        string name = null;
+
+                        if (16 > i && specialPermissions.Length > i)
+                        {
+                            name = specialPermissions[i];
+                        }
+                        else if (28 > i && UtilConstants.StandardPermissions.Length > (i - 16))
+                        {
+                            name = UtilConstants.StandardPermissions[i - 16];
+                        }
+                        else if (0 <= (i - 28) && UtilConstants.GenericPermissions.Length > (i - 28))
+                        {
+                            name = UtilConstants.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 "ChangePermission":
+                                    fileSharePermission.ChangePermission = Util.YesNoType.yes;
+                                    break;
+                                case "CreateChild":
+                                    fileSharePermission.CreateChild = Util.YesNoType.yes;
+                                    break;
+                                case "CreateFile":
+                                    fileSharePermission.CreateFile = Util.YesNoType.yes;
+                                    break;
+                                case "Delete":
+                                    fileSharePermission.Delete = Util.YesNoType.yes;
+                                    break;
+                                case "DeleteChild":
+                                    fileSharePermission.DeleteChild = Util.YesNoType.yes;
+                                    break;
+                                case "GenericAll":
+                                    fileSharePermission.GenericAll = Util.YesNoType.yes;
+                                    break;
+                                case "GenericExecute":
+                                    fileSharePermission.GenericExecute = Util.YesNoType.yes;
+                                    break;
+                                case "GenericRead":
+                                    fileSharePermission.GenericRead = Util.YesNoType.yes;
+                                    break;
+                                case "GenericWrite":
+                                    fileSharePermission.GenericWrite = Util.YesNoType.yes;
+                                    break;
+                                case "Read":
+                                    fileSharePermission.Read = Util.YesNoType.yes;
+                                    break;
+                                case "ReadAttributes":
+                                    fileSharePermission.ReadAttributes = Util.YesNoType.yes;
+                                    break;
+                                case "ReadExtendedAttributes":
+                                    fileSharePermission.ReadExtendedAttributes = Util.YesNoType.yes;
+                                    break;
+                                case "ReadPermission":
+                                    fileSharePermission.ReadPermission = Util.YesNoType.yes;
+                                    break;
+                                case "Synchronize":
+                                    fileSharePermission.Synchronize = Util.YesNoType.yes;
+                                    break;
+                                case "TakeOwnership":
+                                    fileSharePermission.TakeOwnership = Util.YesNoType.yes;
+                                    break;
+                                case "Traverse":
+                                    fileSharePermission.Traverse = Util.YesNoType.yes;
+                                    break;
+                                case "WriteAttributes":
+                                    fileSharePermission.WriteAttributes = Util.YesNoType.yes;
+                                    break;
+                                case "WriteExtendedAttributes":
+                                    fileSharePermission.WriteExtendedAttributes = Util.YesNoType.yes;
+                                    break;
+                                default:
+                                    Debug.Fail(String.Format("Unknown permission '{0}'.", name));
+                                    break;
+                            }
+                        }
+                    }
+                }
+
+                Util.FileShare fileShare = (Util.FileShare)this.Core.GetIndexedElement("FileShare", (string)row[0]);
+                if (null != fileShare)
+                {
+                    fileShare.AddChild(fileSharePermission);
+                }
+                else
+                {
+                    this.Core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "FileShare_", (string)row[0], "FileShare"));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the Group table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileGroupTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Util.Group group = new Util.Group();
+
+                group.Id = (string)row[0];
+
+                if (null != row[1])
+                {
+                    this.Core.OnMessage(WixWarnings.UnrepresentableColumnValue(row.SourceLineNumbers, table.Name, "Component_", (string)row[1]));
+                }
+
+                group.Name = (string)row[2];
+
+                if (null != row[3])
+                {
+                    group.Domain = (string)row[3];
+                }
+
+                this.Core.RootElement.AddChild(group);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the WixInternetShortcut table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileWixInternetShortcutTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Util.InternetShortcut internetShortcut = new Util.InternetShortcut();
+                internetShortcut.Id = (string)row[0];
+                internetShortcut.Directory = (string)row[2];
+                // remove .lnk/.url extension because compiler extension adds it back for us
+                internetShortcut.Name = Path.ChangeExtension((string)row[3], null);
+                internetShortcut.Target = (string)row[4];
+                internetShortcut.IconFile = (string)row[6];
+                internetShortcut.IconIndex = (int)row[7];
+
+                UtilCompiler.InternetShortcutType shortcutType = (UtilCompiler.InternetShortcutType)row[5];
+                switch (shortcutType)
+                {
+                    case UtilCompiler.InternetShortcutType.Link:
+                        internetShortcut.Type = Util.InternetShortcut.TypeType.link;
+                        break;
+                    case UtilCompiler.InternetShortcutType.Url:
+                        internetShortcut.Type = Util.InternetShortcut.TypeType.url;
+                        break;
+                }
+
+                Wix.Component component = (Wix.Component)this.Core.GetIndexedElement("Component", (string)row[1]);
+                if (null != component)
+                {
+                    component.AddChild(internetShortcut);
+                }
+                else
+                {
+                    this.Core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", (string)row[1], "Component"));
+                }
+
+                this.Core.IndexElement(row, internetShortcut);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the Perfmon table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompilePerfmonTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Util.PerfCounter perfCounter = new Util.PerfCounter();
+
+                perfCounter.Name = (string)row[2];
+
+                this.Core.IndexElement(row, perfCounter);
+            }
+        }
+        
+        /// <summary>
+        /// Decompile the PerfmonManifest table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompilePerfmonManifestTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Util.PerfCounterManifest perfCounterManifest = new Util.PerfCounterManifest();
+
+                perfCounterManifest.ResourceFileDirectory = (string)row[2];
+
+                this.Core.IndexElement(row, perfCounterManifest);
+            }
+        }
+        
+        /// <summary>
+        /// Decompile the EventManifest table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileEventManifestTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Util.EventManifest eventManifest = new Util.EventManifest();
+                this.Core.IndexElement(row, eventManifest);
+            }
+        }
+        
+        /// <summary>
+        /// Decompile the SecureObjects table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileSecureObjectsTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Util.PermissionEx permissionEx = new Util.PermissionEx();
+
+                string[] specialPermissions;
+                switch ((string)row[1])
+                {
+                    case "CreateFolder":
+                        specialPermissions = UtilConstants.FolderPermissions;
+                        break;
+                    case "File":
+                        specialPermissions = UtilConstants.FilePermissions;
+                        break;
+                    case "Registry":
+                        specialPermissions = UtilConstants.RegistryPermissions;
+                        break;
+                    case "ServiceInstall":
+                        specialPermissions = UtilConstants.ServicePermissions;
+                        break;
+                    default:
+                        this.Core.OnMessage(WixWarnings.IllegalColumnValue(row.SourceLineNumbers, row.Table.Name, row.Fields[1].Column.Name, row[1]));
+                        return;
+                }
+
+                int permissionBits = (int)row[4];
+                for (int i = 0; i < 32; i++)
+                {
+                    if (0 != ((permissionBits >> i) & 1))
+                    {
+                        string name = null;
+
+                        if (16 > i && specialPermissions.Length > i)
+                        {
+                            name = specialPermissions[i];
+                        }
+                        else if (28 > i && UtilConstants.StandardPermissions.Length > (i - 16))
+                        {
+                            name = UtilConstants.StandardPermissions[i - 16];
+                        }
+                        else if (0 <= (i - 28) && UtilConstants.GenericPermissions.Length > (i - 28))
+                        {
+                            name = UtilConstants.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":
+                                    permissionEx.Append = Util.YesNoType.yes;
+                                    break;
+                                case "ChangePermission":
+                                    permissionEx.ChangePermission = Util.YesNoType.yes;
+                                    break;
+                                case "CreateChild":
+                                    permissionEx.CreateChild = Util.YesNoType.yes;
+                                    break;
+                                case "CreateFile":
+                                    permissionEx.CreateFile = Util.YesNoType.yes;
+                                    break;
+                                case "CreateLink":
+                                    permissionEx.CreateLink = Util.YesNoType.yes;
+                                    break;
+                                case "CreateSubkeys":
+                                    permissionEx.CreateSubkeys = Util.YesNoType.yes;
+                                    break;
+                                case "Delete":
+                                    permissionEx.Delete = Util.YesNoType.yes;
+                                    break;
+                                case "DeleteChild":
+                                    permissionEx.DeleteChild = Util.YesNoType.yes;
+                                    break;
+                                case "EnumerateSubkeys":
+                                    permissionEx.EnumerateSubkeys = Util.YesNoType.yes;
+                                    break;
+                                case "Execute":
+                                    permissionEx.Execute = Util.YesNoType.yes;
+                                    break;
+                                case "GenericAll":
+                                    permissionEx.GenericAll = Util.YesNoType.yes;
+                                    break;
+                                case "GenericExecute":
+                                    permissionEx.GenericExecute = Util.YesNoType.yes;
+                                    break;
+                                case "GenericRead":
+                                    permissionEx.GenericRead = Util.YesNoType.yes;
+                                    break;
+                                case "GenericWrite":
+                                    permissionEx.GenericWrite = Util.YesNoType.yes;
+                                    break;
+                                case "Notify":
+                                    permissionEx.Notify = Util.YesNoType.yes;
+                                    break;
+                                case "Read":
+                                    permissionEx.Read = Util.YesNoType.yes;
+                                    break;
+                                case "ReadAttributes":
+                                    permissionEx.ReadAttributes = Util.YesNoType.yes;
+                                    break;
+                                case "ReadExtendedAttributes":
+                                    permissionEx.ReadExtendedAttributes = Util.YesNoType.yes;
+                                    break;
+                                case "ReadPermission":
+                                    permissionEx.ReadPermission = Util.YesNoType.yes;
+                                    break;
+                                case "ServiceChangeConfig":
+                                    permissionEx.ServiceChangeConfig = Util.YesNoType.yes;
+                                    break;
+                                case "ServiceEnumerateDependents":
+                                    permissionEx.ServiceEnumerateDependents = Util.YesNoType.yes;
+                                    break;
+                                case "ServiceInterrogate":
+                                    permissionEx.ServiceInterrogate = Util.YesNoType.yes;
+                                    break;
+                                case "ServicePauseContinue":
+                                    permissionEx.ServicePauseContinue = Util.YesNoType.yes;
+                                    break;
+                                case "ServiceQueryConfig":
+                                    permissionEx.ServiceQueryConfig = Util.YesNoType.yes;
+                                    break;
+                                case "ServiceQueryStatus":
+                                    permissionEx.ServiceQueryStatus = Util.YesNoType.yes;
+                                    break;
+                                case "ServiceStart":
+                                    permissionEx.ServiceStart = Util.YesNoType.yes;
+                                    break;
+                                case "ServiceStop":
+                                    permissionEx.ServiceStop = Util.YesNoType.yes;
+                                    break;
+                                case "ServiceUserDefinedControl":
+                                    permissionEx.ServiceUserDefinedControl = Util.YesNoType.yes;
+                                    break;
+                                case "Synchronize":
+                                    permissionEx.Synchronize = Util.YesNoType.yes;
+                                    break;
+                                case "TakeOwnership":
+                                    permissionEx.TakeOwnership = Util.YesNoType.yes;
+                                    break;
+                                case "Traverse":
+                                    permissionEx.Traverse = Util.YesNoType.yes;
+                                    break;
+                                case "Write":
+                                    permissionEx.Write = Util.YesNoType.yes;
+                                    break;
+                                case "WriteAttributes":
+                                    permissionEx.WriteAttributes = Util.YesNoType.yes;
+                                    break;
+                                case "WriteExtendedAttributes":
+                                    permissionEx.WriteExtendedAttributes = Util.YesNoType.yes;
+                                    break;
+                                default:
+                                    throw new InvalidOperationException(String.Format("Unknown permission attribute '{0}'.", name));
+                            }
+                        }
+                    }
+                }
+
+                if (null != row[2])
+                {
+                    permissionEx.Domain = (string)row[2];
+                }
+
+                permissionEx.User = (string)row[3];
+
+                this.Core.IndexElement(row, permissionEx);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the ServiceConfig table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileServiceConfigTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Util.ServiceConfig serviceConfig = new Util.ServiceConfig();
+
+                serviceConfig.ServiceName = (string)row[0];
+
+                switch ((string)row[3])
+                {
+                    case "none":
+                        serviceConfig.FirstFailureActionType = Util.ServiceConfig.FirstFailureActionTypeType.none;
+                        break;
+                    case "reboot":
+                        serviceConfig.FirstFailureActionType = Util.ServiceConfig.FirstFailureActionTypeType.reboot;
+                        break;
+                    case "restart":
+                        serviceConfig.FirstFailureActionType = Util.ServiceConfig.FirstFailureActionTypeType.restart;
+                        break;
+                    case "runCommand":
+                        serviceConfig.FirstFailureActionType = Util.ServiceConfig.FirstFailureActionTypeType.runCommand;
+                        break;
+                    default:
+                        this.Core.OnMessage(WixWarnings.IllegalColumnValue(row.SourceLineNumbers, table.Name, row.Fields[3].Column.Name, row[3]));
+                        break;
+                }
+
+                switch ((string)row[4])
+                {
+                    case "none":
+                        serviceConfig.SecondFailureActionType = Util.ServiceConfig.SecondFailureActionTypeType.none;
+                        break;
+                    case "reboot":
+                        serviceConfig.SecondFailureActionType = Util.ServiceConfig.SecondFailureActionTypeType.reboot;
+                        break;
+                    case "restart":
+                        serviceConfig.SecondFailureActionType = Util.ServiceConfig.SecondFailureActionTypeType.restart;
+                        break;
+                    case "runCommand":
+                        serviceConfig.SecondFailureActionType = Util.ServiceConfig.SecondFailureActionTypeType.runCommand;
+                        break;
+                    default:
+                        this.Core.OnMessage(WixWarnings.IllegalColumnValue(row.SourceLineNumbers, table.Name, row.Fields[4].Column.Name, row[4]));
+                        break;
+                }
+
+                switch ((string)row[5])
+                {
+                    case "none":
+                        serviceConfig.ThirdFailureActionType = Util.ServiceConfig.ThirdFailureActionTypeType.none;
+                        break;
+                    case "reboot":
+                        serviceConfig.ThirdFailureActionType = Util.ServiceConfig.ThirdFailureActionTypeType.reboot;
+                        break;
+                    case "restart":
+                        serviceConfig.ThirdFailureActionType = Util.ServiceConfig.ThirdFailureActionTypeType.restart;
+                        break;
+                    case "runCommand":
+                        serviceConfig.ThirdFailureActionType = Util.ServiceConfig.ThirdFailureActionTypeType.runCommand;
+                        break;
+                    default:
+                        this.Core.OnMessage(WixWarnings.IllegalColumnValue(row.SourceLineNumbers, table.Name, row.Fields[5].Column.Name, row[5]));
+                        break;
+                }
+
+                if (null != row[6])
+                {
+                    serviceConfig.ResetPeriodInDays = (int)row[6];
+                }
+
+                if (null != row[7])
+                {
+                    serviceConfig.RestartServiceDelayInSeconds = (int)row[7];
+                }
+
+                if (null != row[8])
+                {
+                    serviceConfig.ProgramCommandLine = (string)row[8];
+                }
+
+                if (null != row[9])
+                {
+                    serviceConfig.RebootMessage = (string)row[9];
+                }
+
+                this.Core.IndexElement(row, serviceConfig);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the User table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileUserTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Util.User user = new Util.User();
+
+                user.Id = (string)row[0];
+
+                user.Name = (string)row[2];
+
+                if (null != row[3])
+                {
+                    user.Domain = (string)row[3];
+                }
+
+                if (null != row[4])
+                {
+                    user.Password = (string)row[4];
+                }
+
+                if (null != row[5])
+                {
+                    int attributes = (int)row[5];
+
+                    if (UtilCompiler.UserDontExpirePasswrd == (attributes & UtilCompiler.UserDontExpirePasswrd))
+                    {
+                        user.PasswordNeverExpires = Util.YesNoType.yes;
+                    }
+
+                    if (UtilCompiler.UserPasswdCantChange == (attributes & UtilCompiler.UserPasswdCantChange))
+                    {
+                        user.CanNotChangePassword = Util.YesNoType.yes;
+                    }
+
+                    if (UtilCompiler.UserPasswdChangeReqdOnLogin == (attributes & UtilCompiler.UserPasswdChangeReqdOnLogin))
+                    {
+                        user.PasswordExpired = Util.YesNoType.yes;
+                    }
+
+                    if (UtilCompiler.UserDisableAccount == (attributes & UtilCompiler.UserDisableAccount))
+                    {
+                        user.Disabled = Util.YesNoType.yes;
+                    }
+
+                    if (UtilCompiler.UserFailIfExists == (attributes & UtilCompiler.UserFailIfExists))
+                    {
+                        user.FailIfExists = Util.YesNoType.yes;
+                    }
+
+                    if (UtilCompiler.UserUpdateIfExists == (attributes & UtilCompiler.UserUpdateIfExists))
+                    {
+                        user.UpdateIfExists = Util.YesNoType.yes;
+                    }
+
+                    if (UtilCompiler.UserLogonAsService == (attributes & UtilCompiler.UserLogonAsService))
+                    {
+                        user.LogonAsService = Util.YesNoType.yes;
+                    }
+                    
+                    if (UtilCompiler.UserDontRemoveOnUninstall == (attributes & UtilCompiler.UserDontRemoveOnUninstall))
+                    {
+                        user.RemoveOnUninstall = Util.YesNoType.no;
+                    }
+
+                    if (UtilCompiler.UserDontCreateUser == (attributes & UtilCompiler.UserDontCreateUser))
+                    {
+                        user.CreateUser = Util.YesNoType.no;
+                    }
+
+                    if (UtilCompiler.UserNonVital == (attributes & UtilCompiler.UserNonVital))
+                    {
+                        user.Vital = Util.YesNoType.no;
+                    }
+                }
+
+                if (null != row[1])
+                {
+                    Wix.Component component = (Wix.Component)this.Core.GetIndexedElement("Component", (string)row[1]);
+
+                    if (null != component)
+                    {
+                        component.AddChild(user);
+                    }
+                    else
+                    {
+                        this.Core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", (string)row[1], "Component"));
+                    }
+                }
+                else
+                {
+                    this.Core.RootElement.AddChild(user);
+                }
+                this.Core.IndexElement(row, user);
+            }
+        }
+
+        /// <summary>
+        /// Decompile the UserGroup table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileUserGroupTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Util.User user = (Util.User)this.Core.GetIndexedElement("User", (string)row[0]);
+
+                if (null != user)
+                {
+                    Util.GroupRef groupRef = new Util.GroupRef();
+
+                    groupRef.Id = (string)row[1];
+
+                    user.AddChild(groupRef);
+                }
+                else
+                {
+                    this.Core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, table.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Group_", (string)row[0], "Group"));
+                }
+            }
+        }
+
+        /// <summary>
+        /// Decompile the XmlConfig table.
+        /// </summary>
+        /// <param name="table">The table to decompile.</param>
+        private void DecompileXmlConfigTable(Table table)
+        {
+            foreach (Row row in table.Rows)
+            {
+                Util.XmlConfig xmlConfig = new Util.XmlConfig();
+
+                xmlConfig.Id = (string)row[0];
+
+                xmlConfig.File = (string)row[1];
+
+                xmlConfig.ElementPath = (string)row[2];
+
+                if (null != row[3])
+                {
+                    xmlConfig.VerifyPath = (string)row[3];
+                }
+
+                if (null != row[4])
+                {
+                    xmlConfig.Name = (string)row[4];
+                }
+
+                if (null != row[5])
+                {
+                    xmlConfig.Value = (string)row[5];
+                }
+
+                int flags = (int)row[6];
+
+                if (0x1 == (flags & 0x1))
+                {
+                    xmlConfig.Node = Util.XmlConfig.NodeType.element;
+                }
+                else if (0x2 == (flags & 0x2))
+                {
+                    xmlConfig.Node = Util.XmlConfig.NodeType.value;
+                }
+                else if (0x4 == (flags & 0x4))
+                {
+                    xmlConfig.Node = Util.XmlConfig.NodeType.document;
+                }
+
+                if (0x10 == (flags & 0x10))
+                {
+                    xmlConfig.Action = Util.XmlConfig.ActionType.create;
+                }
+                else if (0x20 == (flags & 0x20))
+                {
+                    xmlConfig.Action = Util.XmlConfig.ActionType.delete;
+                }
+
+                if (0x100 == (flags & 0x100))
+                {
+                    xmlConfig.On = Util.XmlConfig.OnType.install;
+                }
+                else if (0x200 == (flags & 0x200))
+                {
+                    xmlConfig.On = Util.XmlConfig.OnType.uninstall;
+                }
+
+                if (0x00001000 == (flags & 0x00001000))
+                {
+                    xmlConfig.PreserveModifiedDate = Util.YesNoType.yes;
+                }
+
+                if (null != row[8])
+                {
+                    xmlConfig.Sequence = (int)row[8];
+                }
+
+                this.Core.IndexElement(row, xmlConfig);
+            }
+        }
+
+        /// <summary>
+        /// Finalize the Perfmon table.
+        /// </summary>
+        /// <param name="tables">The collection of all tables.</param>
+        /// <remarks>
+        /// Since the PerfCounter element nests under a File element, but
+        /// the Perfmon table does not have a foreign key relationship with
+        /// the File table (instead it has a formatted string that usually
+        /// refers to a file row - but doesn't have to), the nesting must
+        /// be inferred during finalization.
+        /// </remarks>
+        private void FinalizePerfmonTable(TableIndexedCollection tables)
+        {
+            Table perfmonTable = tables["Perfmon"];
+
+            if (null != perfmonTable)
+            {
+                foreach (Row row in perfmonTable.Rows)
+                {
+                    string formattedFile = (string)row[1];
+                    Util.PerfCounter perfCounter = (Util.PerfCounter)this.Core.GetIndexedElement(row);
+
+                    // try to "de-format" the File column's value to determine the proper parent File element
+                    if ((formattedFile.StartsWith("[#", StringComparison.Ordinal) || formattedFile.StartsWith("[!", StringComparison.Ordinal))
+                        && formattedFile.EndsWith("]", StringComparison.Ordinal))
+                    {
+                        string fileId = formattedFile.Substring(2, formattedFile.Length - 3);
+
+                        Wix.File file = (Wix.File)this.Core.GetIndexedElement("File", fileId);
+                        if (null != file)
+                        {
+                            file.AddChild(perfCounter);
+                        }
+                        else
+                        {
+                            this.Core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, perfmonTable.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "File", formattedFile, "File"));
+                        }
+                    }
+                    else
+                    {
+                        this.Core.OnMessage(UtilErrors.IllegalFileValueInPerfmonOrManifest(formattedFile, "Perfmon"));
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Finalize the PerfmonManifest table.
+        /// </summary>
+        /// <param name="tables">The collection of all tables.</param>
+        private void FinalizePerfmonManifestTable(TableIndexedCollection tables)
+        {
+            Table perfmonManifestTable = tables["PerfmonManifest"];
+
+            if (null != perfmonManifestTable)
+            {
+                foreach (Row row in perfmonManifestTable.Rows)
+                {
+                    string formattedFile = (string)row[1];
+                    Util.PerfCounterManifest perfCounterManifest = (Util.PerfCounterManifest)this.Core.GetIndexedElement(row);
+
+                    // try to "de-format" the File column's value to determine the proper parent File element
+                    if ((formattedFile.StartsWith("[#", StringComparison.Ordinal) || formattedFile.StartsWith("[!", StringComparison.Ordinal))
+                        && formattedFile.EndsWith("]", StringComparison.Ordinal))
+                    {
+                        string fileId = formattedFile.Substring(2, formattedFile.Length - 3);
+
+                        Wix.File file = (Wix.File)this.Core.GetIndexedElement("File", fileId);
+                        if (null != file)
+                        {
+                            file.AddChild(perfCounterManifest);
+                        }
+                        else
+                        {
+                            this.Core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, perfCounterManifest.ResourceFileDirectory, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "File", formattedFile, "File"));
+                        }
+                    }
+                    else
+                    {
+                        this.Core.OnMessage(UtilErrors.IllegalFileValueInPerfmonOrManifest(formattedFile, "PerfmonManifest"));
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Finalize the SecureObjects 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 SecureObjects table.
+        /// </remarks>
+        private void FinalizeSecureObjectsTable(TableIndexedCollection tables)
+        {
+            Table createFolderTable = tables["CreateFolder"];
+            Table secureObjectsTable = tables["SecureObjects"];
+
+            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 = (string)row[0];
+
+                    if (!createFolders.Contains(directoryId))
+                    {
+                        createFolders.Add(directoryId, new ArrayList());
+                    }
+                    ((ArrayList)createFolders[directoryId]).Add(createFolder);
+                }
+            }
+
+            if (null != secureObjectsTable)
+            {
+                foreach (Row row in secureObjectsTable.Rows)
+                {
+                    string id = (string)row[0];
+                    string table = (string)row[1];
+
+                    Util.PermissionEx permissionEx = (Util.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, "SecureObjects", 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, "SecureObjects", row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "LockObject", id, table));
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Finalize the ServiceConfig table.
+        /// </summary>
+        /// <param name="tables">The collection of all tables.</param>
+        /// <remarks>
+        /// Since there is no foreign key from the ServiceName column to the
+        /// ServiceInstall table, this relationship must be handled late.
+        /// </remarks>
+        private void FinalizeServiceConfigTable(TableIndexedCollection tables)
+        {
+            Table serviceConfigTable = tables["ServiceConfig"];
+            Table serviceInstallTable = tables["ServiceInstall"];
+
+            Hashtable serviceInstalls = new Hashtable();
+
+            // index the ServiceInstall table because the foreign key used by the ServiceConfig
+            // table is actually the ServiceInstall.Name, not the ServiceInstall.ServiceInstall
+            // this is unfortunate because the service Name is not guaranteed to be unique, so
+            // decompiler must assume there could be multiple matches and add the ServiceConfig to each
+            // TODO: the Component column information should be taken into acount to accurately identify
+            // the correct column to use
+            if (null != serviceInstallTable)
+            {
+                foreach (Row row in serviceInstallTable.Rows)
+                {
+                    string name = (string)row[1];
+                    Wix.ServiceInstall serviceInstall = (Wix.ServiceInstall)this.Core.GetIndexedElement(row);
+
+                    if (!serviceInstalls.Contains(name))
+                    {
+                        serviceInstalls.Add(name, new ArrayList());
+                    }
+
+                    ((ArrayList)serviceInstalls[name]).Add(serviceInstall);
+                }
+            }
+
+            if (null != serviceConfigTable)
+            {
+                foreach (Row row in serviceConfigTable.Rows)
+                {
+                    Util.ServiceConfig serviceConfig = (Util.ServiceConfig)this.Core.GetIndexedElement(row);
+
+                    if (0 == (int)row[2])
+                    {
+                        Wix.Component component = (Wix.Component)this.Core.GetIndexedElement("Component", (string)row[1]);
+
+                        if (null != component)
+                        {
+                            component.AddChild(serviceConfig);
+                        }
+                        else
+                        {
+                            this.Core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, serviceConfigTable.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", (string)row[1], "Component"));
+                        }
+                    }
+                    else
+                    {
+                        ArrayList serviceInstallElements = (ArrayList)serviceInstalls[row[0]];
+
+                        if (null != serviceInstallElements)
+                        {
+                            foreach (Wix.ServiceInstall serviceInstall in serviceInstallElements)
+                            {
+                                serviceInstall.AddChild(serviceConfig);
+                            }
+                        }
+                        else
+                        {
+                            this.Core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, serviceConfigTable.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "ServiceName", (string)row[0], "ServiceInstall"));
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Finalize the XmlConfig table.
+        /// </summary>
+        /// <param name="tables">Collection of all tables.</param>
+        private void FinalizeXmlConfigTable(TableIndexedCollection tables)
+        {
+            Table xmlConfigTable = tables["XmlConfig"];
+
+            if (null != xmlConfigTable)
+            {
+                foreach (Row row in xmlConfigTable.Rows)
+                {
+                    Util.XmlConfig xmlConfig = (Util.XmlConfig)this.Core.GetIndexedElement(row);
+
+                    if (null == row[6] || 0 == (int)row[6])
+                    {
+                        Util.XmlConfig parentXmlConfig = (Util.XmlConfig)this.Core.GetIndexedElement("XmlConfig", (string)row[2]);
+
+                        if (null != parentXmlConfig)
+                        {
+                            parentXmlConfig.AddChild(xmlConfig);
+                        }
+                        else
+                        {
+                            this.Core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, xmlConfigTable.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "ElementPath", (string)row[2], "XmlConfig"));
+                        }
+                    }
+                    else
+                    {
+                        Wix.Component component = (Wix.Component)this.Core.GetIndexedElement("Component", (string)row[7]);
+
+                        if (null != component)
+                        {
+                            component.AddChild(xmlConfig);
+                        }
+                        else
+                        {
+                            this.Core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, xmlConfigTable.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", (string)row[7], "Component"));
+                        }
+                    }
+                }
+            }
+        }
+
+
+        /// <summary>
+        /// Finalize the XmlFile table.
+        /// </summary>
+        /// <param name="tables">The collection of all tables.</param>
+        /// <remarks>
+        /// Some of the XmlFile table rows are compiler generated from util:EventManifest node
+        /// These rows should not be appended to component.
+        /// </remarks>
+        private void FinalizeXmlFileTable(TableIndexedCollection tables)
+        {
+            Table xmlFileTable = tables["XmlFile"];
+            Table eventManifestTable = tables["EventManifest"];
+
+            if (null != xmlFileTable)
+            {
+                foreach (Row row in xmlFileTable.Rows)
+                {
+                    bool bManifestGenerated = false;
+                    string xmlFileConfigId = (string)row[0];
+                    if (null != eventManifestTable)
+                    {
+                        foreach (Row emrow in eventManifestTable.Rows)
+                        {
+                            string formattedFile = (string)emrow[1];
+                            if ((formattedFile.StartsWith("[#", StringComparison.Ordinal) || formattedFile.StartsWith("[!", StringComparison.Ordinal))
+                                && formattedFile.EndsWith("]", StringComparison.Ordinal))
+                            {
+                                string fileId = formattedFile.Substring(2, formattedFile.Length - 3);
+                                if (String.Equals(String.Concat("Config_", fileId, "ResourceFile"), xmlFileConfigId))
+                                {
+                                    Util.EventManifest eventManifest = (Util.EventManifest)this.Core.GetIndexedElement(emrow);
+                                    if (null != eventManifest)
+                                    {
+                                        eventManifest.ResourceFile = (string)row[4];
+                                    }
+                                    bManifestGenerated = true;
+                                }
+                                
+                                else if (String.Equals(String.Concat("Config_", fileId, "MessageFile"), xmlFileConfigId))
+                                {
+                                    Util.EventManifest eventManifest = (Util.EventManifest)this.Core.GetIndexedElement(emrow);
+                                    if (null != eventManifest)
+                                    {
+                                        eventManifest.MessageFile = (string)row[4];
+                                    }
+                                    bManifestGenerated = true;
+                                }
+                            }
+                        }
+                    }
+
+                    if (true == bManifestGenerated)
+                        continue;
+                    
+                    Util.XmlFile xmlFile = new Util.XmlFile();
+
+                    xmlFile.Id = (string)row[0];
+                    xmlFile.File = (string)row[1];
+                    xmlFile.ElementPath = (string)row[2];
+
+                    if (null != row[3])
+                    {
+                        xmlFile.Name = (string)row[3];
+                    }
+
+                    if (null != row[4])
+                    {
+                        xmlFile.Value = (string)row[4];
+                    }
+
+                    int flags = (int)row[5];
+                    if (0x1 == (flags & 0x1) && 0x2 == (flags & 0x2))
+                    {
+                        this.Core.OnMessage(WixWarnings.IllegalColumnValue(row.SourceLineNumbers, xmlFileTable.Name, row.Fields[5].Column.Name, row[5]));
+                    }
+                    else if (0x1 == (flags & 0x1))
+                    {
+                        xmlFile.Action = Util.XmlFile.ActionType.createElement;
+                    }
+                    else if (0x2 == (flags & 0x2))
+                    {
+                        xmlFile.Action = Util.XmlFile.ActionType.deleteValue;
+                    }
+                    else
+                    {
+                        xmlFile.Action = Util.XmlFile.ActionType.setValue;
+                    }
+
+                    if (0x100 == (flags & 0x100))
+                    {
+                        xmlFile.SelectionLanguage = Util.XmlFile.SelectionLanguageType.XPath;
+                    }
+
+                    if (0x00001000 == (flags & 0x00001000))
+                    {
+                        xmlFile.PreserveModifiedDate = Util.YesNoType.yes;
+                    }
+
+                    if (0x00010000 == (flags & 0x00010000))
+                    {
+                        xmlFile.Permanent = Util.YesNoType.yes;
+                    }
+
+                    if (null != row[7])
+                    {
+                        xmlFile.Sequence = (int)row[7];
+                    }
+
+                    Wix.Component component = (Wix.Component)this.Core.GetIndexedElement("Component", (string)row[6]);
+
+                    if (null != component)
+                    {
+                        component.AddChild(xmlFile);
+                    }
+                    else
+                    {
+                        this.Core.OnMessage(WixWarnings.ExpectedForeignRow(row.SourceLineNumbers, xmlFileTable.Name, row.GetPrimaryKey(DecompilerConstants.PrimaryKeyDelimiter), "Component_", (string)row[6], "Component"));
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Finalize the eventManifest table.
+        /// This function must be called after FinalizeXmlFileTable
+        /// </summary>
+        /// <param name="tables">The collection of all tables.</param>
+        private void FinalizeEventManifestTable(TableIndexedCollection tables)
+        {
+            Table eventManifestTable = tables["EventManifest"];
+
+            if (null != eventManifestTable)
+            {
+                foreach (Row row in eventManifestTable.Rows)
+                {
+                    string formattedFile = (string)row[1];
+                    Util.EventManifest eventManifest = (Util.EventManifest)this.Core.GetIndexedElement(row);
+
+                    // try to "de-format" the File column's value to determine the proper parent File element
+                    if ((formattedFile.StartsWith("[#", StringComparison.Ordinal) || formattedFile.StartsWith("[!", StringComparison.Ordinal))
+                        && formattedFile.EndsWith("]", StringComparison.Ordinal))
+                    {
+                        string fileId = formattedFile.Substring(2, formattedFile.Length - 3);
+
+                        Wix.File file = (Wix.File)this.Core.GetIndexedElement("File", fileId);
+                        if (null != file)
+                        {
+                            file.AddChild(eventManifest);
+                        }
+                    }
+                    else
+                    {
+                       this.Core.OnMessage(UtilErrors.IllegalFileValueInPerfmonOrManifest(formattedFile, "EventManifest"));
+                    }
+                }
+            }
+        }
+    }
+#endif
+}
diff --git a/src/ext/Util/wixext/UtilErrors.cs b/src/ext/Util/wixext/UtilErrors.cs
new file mode 100644
index 00000000..b9ce1688
--- /dev/null
+++ b/src/ext/Util/wixext/UtilErrors.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.Util
+{
+    using System;
+    using System.Resources;
+    using WixToolset.Data;
+
+    public static class UtilErrors
+    {
+        public static Message IllegalAttributeWithoutComponent(SourceLineNumber sourceLineNumbers, string elementName, string attributeName)
+        {
+            return Message(sourceLineNumbers, Ids.IllegalAttributeWithoutComponent, "The {0}/@{1} attribute cannot be specified unless the element has a Component as an ancestor. A {0} that does not have a Component ancestor is not installed.", elementName, attributeName);
+        }
+
+        public static Message IllegalElementWithoutComponent(SourceLineNumber sourceLineNumbers, string elementName)
+        {
+            return Message(sourceLineNumbers, Ids.IllegalElementWithoutComponent, "The {0} element cannot be specified unless the element has a Component as an ancestor. A {0} that does not have a Component ancestor is not installed.", elementName);
+        }
+
+        public static Message IllegalFileValueInPerfmonOrManifest(string file, string table)
+        {
+            return Message(null, Ids.IllegalFileValueInPerfmonOrManifest, "The value '{0}' in the File column, {1} table is invalid. It should be in the form of '[#file]' or '[!file]'.", file, table);
+        }
+
+        public static Message InvalidRegistryObject(SourceLineNumber sourceLineNumbers, string registryElementName)
+        {
+            return Message(sourceLineNumbers, Ids.InvalidRegistryObject, "The {0} element has no id and cannot have its permissions set. If you want to set permissions on a 'placeholder' registry key, force its creation by setting the ForceCreateOnInstall attribute to yes.", registryElementName);
+        }
+
+        private static Message Message(SourceLineNumber sourceLineNumber, Ids id, string format, params object[] args)
+        {
+            return new Message(sourceLineNumber, MessageLevel.Error, (int)id, format, args);
+        }
+
+        private static Message Message(SourceLineNumber sourceLineNumber, Ids id, ResourceManager resourceManager, string resourceName, params object[] args)
+        {
+            return new Message(sourceLineNumber, MessageLevel.Error, (int)id, resourceManager, resourceName, args);
+        }
+
+        public enum Ids
+        {
+            IllegalAttributeWithoutComponent = 5050,
+            IllegalElementWithoutComponent = 5051,
+            IllegalFileValueInPerfmonOrManifest = 5054,
+            InvalidRegistryObject = 5063,
+        }
+    }
+}
diff --git a/src/ext/Util/wixext/UtilExtensionData.cs b/src/ext/Util/wixext/UtilExtensionData.cs
new file mode 100644
index 00000000..d3ca3358
--- /dev/null
+++ b/src/ext/Util/wixext/UtilExtensionData.cs
@@ -0,0 +1,23 @@
+// 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.Util
+{
+    using WixToolset.Data;
+    using WixToolset.Extensibility;
+
+    public sealed class UtilExtensionData : BaseExtensionData
+    {
+        public override string DefaultCulture => "en-US";
+
+        public override bool TryGetSymbolDefinitionByName(string name, out IntermediateSymbolDefinition symbolDefinition)
+        {
+            symbolDefinition = UtilSymbolDefinitions.ByName(name);
+            return symbolDefinition != null;
+        }
+
+        public override Intermediate GetLibrary(ISymbolDefinitionCreator symbolDefinitions)
+        {
+            return Intermediate.Load(typeof(UtilExtensionData).Assembly, "WixToolset.Util.util.wixlib", symbolDefinitions);
+        }
+    }
+}
diff --git a/src/ext/Util/wixext/UtilExtensionFactory.cs b/src/ext/Util/wixext/UtilExtensionFactory.cs
new file mode 100644
index 00000000..08352813
--- /dev/null
+++ b/src/ext/Util/wixext/UtilExtensionFactory.cs
@@ -0,0 +1,18 @@
+// 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.Util
+{
+    using System;
+    using System.Collections.Generic;
+    using WixToolset.Extensibility;
+
+    public class UtilExtensionFactory : BaseExtensionFactory
+    {
+        protected override IReadOnlyCollection<Type> ExtensionTypes => new[]
+        {
+            typeof(UtilCompiler),
+            typeof(UtilExtensionData),
+            typeof(UtilWindowsInstallerBackendBinderExtension),
+        };
+    }
+}
diff --git a/src/ext/Util/wixext/UtilTableDefinitions.cs b/src/ext/Util/wixext/UtilTableDefinitions.cs
new file mode 100644
index 00000000..12f423cc
--- /dev/null
+++ b/src/ext/Util/wixext/UtilTableDefinitions.cs
@@ -0,0 +1,319 @@
+// 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.Util
+{
+    using WixToolset.Data.WindowsInstaller;
+
+    public static class UtilTableDefinitions
+    {
+        public static readonly TableDefinition Wix4CloseApplication = new TableDefinition(
+            "Wix4CloseApplication",
+            UtilSymbolDefinitions.WixCloseApplication,
+            new[]
+            {
+                new ColumnDefinition("Wix4CloseApplication", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Identifier, description: "Primary key, non-localized token in table.", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("Target", ColumnType.Localized, 0, primaryKey: false, nullable: false, ColumnCategory.Formatted, description: "Name of executable to ensure is closed.", modularizeType: ColumnModularizeType.Property),
+                new ColumnDefinition("Description", ColumnType.String, 0, primaryKey: false, nullable: true, ColumnCategory.Formatted, description: "Description string displayed to user when executable is in use.", modularizeType: ColumnModularizeType.Property, forceLocalizable: true),
+                new ColumnDefinition("Condition", ColumnType.String, 0, primaryKey: false, nullable: true, ColumnCategory.Condition, description: "Optional expression which skips the closing.", modularizeType: ColumnModularizeType.Condition, forceLocalizable: true),
+                new ColumnDefinition("Attributes", ColumnType.Number, 4, primaryKey: false, nullable: false, ColumnCategory.Unknown, minValue: 0, maxValue: 2147483647, description: "A 32-bit word that specifies the attribute flags to be applied."),
+                new ColumnDefinition("Sequence", ColumnType.Number, 4, primaryKey: false, nullable: true, ColumnCategory.Unknown, minValue: 1, maxValue: 2147483647, description: "Sequence to order the closings by."),
+                new ColumnDefinition("Property", ColumnType.String, 72, primaryKey: false, nullable: true, ColumnCategory.Identifier, description: "Optional property that is set to the number of running instances of the app.", modularizeType: ColumnModularizeType.Property, forceLocalizable: true),
+                new ColumnDefinition("TerminateExitCode", ColumnType.Number, 4, primaryKey: false, nullable: true, ColumnCategory.Unknown, minValue: 0, maxValue: 2147483647, description: "Exit code to return from a terminated application."),
+                new ColumnDefinition("Timeout", ColumnType.Number, 4, primaryKey: false, nullable: true, ColumnCategory.Unknown, minValue: 1, maxValue: 2147483647, description: "Timeout in milliseconds before scheduling restart or terminating application."),
+            },
+            symbolIdIsPrimaryKey: true
+        );
+
+        public static readonly TableDefinition Wix4RemoveFolderEx = new TableDefinition(
+            "Wix4RemoveFolderEx",
+            UtilSymbolDefinitions.WixRemoveFolderEx,
+            new[]
+            {
+                new ColumnDefinition("Wix4RemoveFolderEx", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Identifier, description: "Identifier for the WixRemoveFolderEx row in the package.", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("Component_", ColumnType.String, 72, primaryKey: false, nullable: false, ColumnCategory.Identifier, keyTable: "Component", keyColumn: 1, description: "Foreign key into the Component table used to determine install state", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("Property", ColumnType.String, 72, primaryKey: false, nullable: false, ColumnCategory.Identifier, description: "Name of Property that contains the root of the directory tree to remove.", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("InstallMode", ColumnType.Number, 2, primaryKey: false, nullable: false, ColumnCategory.Unknown, minValue: 1, maxValue: 3, description: "1 == Remove only when the associated component is being installed (msiInstallStateLocal or msiInstallStateSource), 2 == Remove only when the associated component is being removed (msiInstallStateAbsent), 3 = Remove in either of the above cases."),
+                new ColumnDefinition("Condition", ColumnType.String, 0, primaryKey: false, nullable: true, ColumnCategory.Condition, description: "Optional expression which skips the removing of folders.", modularizeType: ColumnModularizeType.Condition, forceLocalizable: true),
+            },
+            symbolIdIsPrimaryKey: true
+        );
+
+        public static readonly TableDefinition Wix4RemoveRegistryKeyEx = new TableDefinition(
+            "Wix4RemoveRegistryKeyEx",
+            UtilSymbolDefinitions.WixRemoveRegistryKeyEx,
+            new[]
+            {
+                new ColumnDefinition("Wix4RemoveRegistryKeyEx", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Identifier, description: "Identifier for the Wix4RemoveRegistryKeyEx row in the package.", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("Component_", ColumnType.String, 72, primaryKey: false, nullable: false, ColumnCategory.Identifier, keyTable: "Component", keyColumn: 1, description: "Foreign key into the Component table used to determine install state", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("Root", ColumnType.Number, 2, primaryKey: false, nullable: false, ColumnCategory.Unknown, minValue: -1, maxValue: 3, description: "The predefined root key for the registry value, one of rrkEnum."),
+                new ColumnDefinition("Key", ColumnType.Localized, 255, primaryKey: false, nullable: false, ColumnCategory.RegPath, description: "The key for the registry value.", modularizeType: ColumnModularizeType.Property),
+                new ColumnDefinition("InstallMode", ColumnType.Number, 2, primaryKey: false, nullable: false, ColumnCategory.Unknown, minValue: 1, maxValue: 3, description: "1 == Remove only when the associated component is being installed (msiInstallStateLocal or msiInstallStateSource), 2 == Remove only when the associated component is being removed (msiInstallStateAbsent), 3 = Remove in either of the above cases."),
+                new ColumnDefinition("Condition", ColumnType.String, 0, primaryKey: false, nullable: true, ColumnCategory.Condition, description: "Optional expression to control whether the registry key is removed.", modularizeType: ColumnModularizeType.Condition, forceLocalizable: true),
+            },
+            symbolIdIsPrimaryKey: true
+        );
+
+        public static readonly TableDefinition Wix4RestartResource = new TableDefinition(
+            "Wix4RestartResource",
+            UtilSymbolDefinitions.WixRestartResource,
+            new[]
+            {
+                new ColumnDefinition("Wix4RestartResource", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Identifier, description: "Primary key, non-localized identifier.", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("Component_", ColumnType.String, 72, primaryKey: false, nullable: true, ColumnCategory.Identifier, keyTable: "Component", keyColumn: 1, description: "Foreign key into the Component table used to determine install state.", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("Resource", ColumnType.String, 0, primaryKey: false, nullable: false, ColumnCategory.Formatted, description: "The resource to be registered with the Restart Manager.", modularizeType: ColumnModularizeType.Property),
+                new ColumnDefinition("Attributes", ColumnType.Number, 4, primaryKey: false, nullable: false, ColumnCategory.Unknown, minValue: 0, maxValue: 2147483647, description: "A 32-bit word that specifies the type of resource and flags used for processing."),
+            },
+            symbolIdIsPrimaryKey: true
+        );
+
+        public static readonly TableDefinition Wix4FileShare = new TableDefinition(
+            "Wix4FileShare",
+            UtilSymbolDefinitions.FileShare,
+            new[]
+            {
+                new ColumnDefinition("Wix4FileShare", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Identifier, description: "Primary key, non-localized identifier", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("ShareName", ColumnType.String, 255, primaryKey: false, nullable: false, ColumnCategory.Formatted, description: "The actual share name used"),
+                new ColumnDefinition("Component_", ColumnType.String, 72, primaryKey: false, nullable: false, ColumnCategory.Identifier, keyTable: "Component", keyColumn: 1, description: "Foreign key into the Component table used to determine install state", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("Description", ColumnType.String, 255, primaryKey: false, nullable: true, ColumnCategory.Text, description: "Description string displayed for the file share"),
+                new ColumnDefinition("Directory_", ColumnType.String, 72, primaryKey: false, nullable: false, ColumnCategory.Identifier, keyTable: "Directory", keyColumn: 1, description: "Foreign key referencing directory that the share is created on", modularizeType: ColumnModularizeType.Column),
+            },
+            symbolIdIsPrimaryKey: true
+        );
+
+        public static readonly TableDefinition Wix4FileSharePermissions = new TableDefinition(
+            "Wix4FileSharePermissions",
+            UtilSymbolDefinitions.FileSharePermissions,
+            new[]
+            {
+                new ColumnDefinition("Wix4FileShare_", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Identifier, keyTable: "FileShare", keyColumn: 1, description: "FileShare that these premissions are to be applied to.", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("Wix4User_", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Identifier, keyTable: "Wix4User", description: "User that these premissions are to apply to.", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("Permissions", ColumnType.Number, 4, primaryKey: false, nullable: false, ColumnCategory.Unknown, description: "Permissions int, as in EXPLICIT_ACCESS.grfAccessPermissions in MSDN"),
+            },
+            symbolIdIsPrimaryKey: false
+        );
+
+        public static readonly TableDefinition Wix4Group = new TableDefinition(
+            "Wix4Group",
+            UtilSymbolDefinitions.Group,
+            new[]
+            {
+                new ColumnDefinition("Wix4Group", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Identifier, description: "Primary key, non-localized token", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("Component_", ColumnType.String, 72, primaryKey: false, nullable: true, ColumnCategory.Text, keyTable: "Component", keyColumn: 1, description: "Foreign key, Component used to determine install state", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("Name", ColumnType.String, 255, primaryKey: false, nullable: false, ColumnCategory.Formatted, description: "Group name", modularizeType: ColumnModularizeType.Property),
+                new ColumnDefinition("Domain", ColumnType.String, 255, primaryKey: false, nullable: true, ColumnCategory.Formatted, description: "Group domain", modularizeType: ColumnModularizeType.Property),
+            },
+            symbolIdIsPrimaryKey: true
+        );
+
+        public static readonly TableDefinition Wix4InternetShortcut = new TableDefinition(
+            "Wix4InternetShortcut",
+            UtilSymbolDefinitions.WixInternetShortcut,
+            new[]
+            {
+                new ColumnDefinition("Wix4InternetShortcut", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Identifier, description: "Primary key, non-localized token in table.", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("Component_", ColumnType.String, 72, primaryKey: false, nullable: false, ColumnCategory.Text, keyTable: "Component", keyColumn: 1, description: "Foreign key, Component used to determine install state", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("Directory_", ColumnType.String, 72, primaryKey: false, nullable: false, ColumnCategory.Identifier, keyTable: "Directory", keyColumn: 1, description: "Foreign key referencing directory that the shortcut is created in", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("Name", ColumnType.String, 72, primaryKey: false, nullable: false, ColumnCategory.Text, description: "Name used for shortcut.", modularizeType: ColumnModularizeType.Property),
+                new ColumnDefinition("Target", ColumnType.Localized, 0, primaryKey: false, nullable: false, ColumnCategory.Text, description: "URL target."),
+                new ColumnDefinition("Attributes", ColumnType.Number, 2, primaryKey: false, nullable: false, ColumnCategory.Unknown, description: "Attribute flags that control how the shortcut is created."),
+                new ColumnDefinition("IconFile", ColumnType.Localized, 0, primaryKey: false, nullable: true, ColumnCategory.Formatted, description: "Icon file for shortcut", modularizeType: ColumnModularizeType.Property),
+                new ColumnDefinition("IconIndex", ColumnType.Number, 4, primaryKey: false, nullable: true, ColumnCategory.Unknown, description: "Index of the icon being referenced."),
+            },
+            symbolIdIsPrimaryKey: true
+        );
+
+        public static readonly TableDefinition Wix4PerformanceCategory = new TableDefinition(
+            "Wix4PerformanceCategory",
+            UtilSymbolDefinitions.PerformanceCategory,
+            new[]
+            {
+                new ColumnDefinition("Wix4PerformanceCategory", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Identifier, description: "Primary key, non-localized token in table.", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("Component_", ColumnType.String, 72, primaryKey: false, nullable: false, ColumnCategory.Identifier, keyTable: "Component", keyColumn: 1, description: "Component used to determine install state", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("Name", ColumnType.String, 80, primaryKey: false, nullable: false, ColumnCategory.Text, description: "Name of the performance counter category."),
+                new ColumnDefinition("IniData", ColumnType.Localized, 0, primaryKey: false, nullable: false, ColumnCategory.Text, description: "Data that goes into the performance counter .ini file."),
+                new ColumnDefinition("ConstantData", ColumnType.Localized, 0, primaryKey: false, nullable: false, ColumnCategory.Text, description: "Data that goes into the performance counter .h file."),
+            },
+            symbolIdIsPrimaryKey: true
+        );
+
+        public static readonly TableDefinition Wix4Perfmon = new TableDefinition(
+            "Wix4Perfmon",
+            UtilSymbolDefinitions.Perfmon,
+            new[]
+            {
+                new ColumnDefinition("Component_", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Identifier, keyTable: "Component", keyColumn: 1, description: "Component used to determine install state", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("File", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Formatted, description: "Name of .INI file", modularizeType: ColumnModularizeType.Property),
+                new ColumnDefinition("Name", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Text, description: "Service name in registry"),
+            },
+            symbolIdIsPrimaryKey: false
+        );
+
+        public static readonly TableDefinition Wix4PerfmonManifest = new TableDefinition(
+            "Wix4PerfmonManifest",
+            UtilSymbolDefinitions.PerfmonManifest,
+            new[]
+            {
+                new ColumnDefinition("Component_", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Identifier, keyTable: "Component", keyColumn: 1, description: "Component used to determine install state", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("File", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Formatted, description: "Name of perfmon manifest file", modularizeType: ColumnModularizeType.Property),
+                new ColumnDefinition("ResourceFileDirectory", ColumnType.String, 255, primaryKey: true, nullable: false, ColumnCategory.Formatted, description: "The path of the Resource File Directory"),
+            },
+            symbolIdIsPrimaryKey: false
+        );
+
+        public static readonly TableDefinition Wix4EventManifest = new TableDefinition(
+            "Wix4EventManifest",
+            UtilSymbolDefinitions.EventManifest,
+            new[]
+            {
+                new ColumnDefinition("Component_", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Identifier, keyTable: "Component", keyColumn: 1, description: "Component used to determine install state", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("File", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Formatted, description: "Name of event manifest file", modularizeType: ColumnModularizeType.Property),
+            },
+            symbolIdIsPrimaryKey: false
+        );
+
+        public static readonly TableDefinition Wix4SecureObject = new TableDefinition(
+            "Wix4SecureObject",
+            UtilSymbolDefinitions.SecureObjects,
+            new[]
+            {
+                new ColumnDefinition("Wix4SecureObject", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Identifier, description: "Primary key, non-localized token in Table", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("Table", ColumnType.String, 32, primaryKey: true, nullable: false, ColumnCategory.Text, description: "Table SecureObject should be securing"),
+                new ColumnDefinition("Domain", ColumnType.String, 255, primaryKey: true, nullable: true, ColumnCategory.Text, description: "Domain half of user account to secure", modularizeType: ColumnModularizeType.Property),
+                new ColumnDefinition("User", ColumnType.String, 255, primaryKey: true, nullable: false, ColumnCategory.Text, description: "User name half of user account to secure", modularizeType: ColumnModularizeType.Property),
+                new ColumnDefinition("Attributes", ColumnType.Number, 4, primaryKey: false, nullable: false, ColumnCategory.Integer, minValue: 0, maxValue: 2147483647, description: "A 32-bit word that specifies the attribute flags to be applied."),
+                new ColumnDefinition("Permission", ColumnType.Number, 4, primaryKey: false, nullable: true, ColumnCategory.Unknown, minValue: -2147483647, maxValue: 2147483647, description: "Permissions to grant to User"),
+                new ColumnDefinition("Component_", ColumnType.String, 72, primaryKey: false, nullable: false, ColumnCategory.Identifier, keyTable: "Component", keyColumn: 1, description: "Foreign key into the Component table used to determine install state", modularizeType: ColumnModularizeType.Column),
+            },
+            symbolIdIsPrimaryKey: false
+        );
+
+        public static readonly TableDefinition Wix4ServiceConfig = new TableDefinition(
+            "Wix4ServiceConfig",
+            UtilSymbolDefinitions.ServiceConfig,
+            new[]
+            {
+                new ColumnDefinition("ServiceName", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Formatted, description: "Primary key, non-localized token"),
+                new ColumnDefinition("Component_", ColumnType.String, 72, primaryKey: false, nullable: false, ColumnCategory.Identifier, keyTable: "Component", keyColumn: 1, description: "Foreign key, Component used to determine install state ", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("NewService", ColumnType.Number, 1, primaryKey: false, nullable: false, ColumnCategory.Unknown, minValue: 0, maxValue: 1, description: "Whether the affected service is being installed or already exists."),
+                new ColumnDefinition("FirstFailureActionType", ColumnType.String, 32, primaryKey: false, nullable: false, ColumnCategory.Text, description: "First failure action type for configured service to take."),
+                new ColumnDefinition("SecondFailureActionType", ColumnType.String, 32, primaryKey: false, nullable: false, ColumnCategory.Text, description: "Second failure action type for configured service to take."),
+                new ColumnDefinition("ThirdFailureActionType", ColumnType.String, 32, primaryKey: false, nullable: false, ColumnCategory.Text, description: "Third failure action type for configured service to take."),
+                new ColumnDefinition("ResetPeriodInDays", ColumnType.Number, 4, primaryKey: false, nullable: true, ColumnCategory.Integer, minValue: 0, description: "Period after which to reset the failure count for the service."),
+                new ColumnDefinition("RestartServiceDelayInSeconds", ColumnType.Number, 4, primaryKey: false, nullable: true, ColumnCategory.Integer, minValue: 0, description: "Period after which to restart the service after a given failure."),
+                new ColumnDefinition("ProgramCommandLine", ColumnType.String, 255, primaryKey: false, nullable: true, ColumnCategory.Formatted, description: "Command line for program to run if failure action is RUN_COMMAND."),
+                new ColumnDefinition("RebootMessage", ColumnType.String, 255, primaryKey: false, nullable: true, ColumnCategory.Text, description: "Message to show to users when rebooting if failure action is REBOOT."),
+            },
+            symbolIdIsPrimaryKey: false
+        );
+
+        public static readonly TableDefinition Wix4TouchFile = new TableDefinition(
+            "Wix4TouchFile",
+            UtilSymbolDefinitions.WixTouchFile,
+            new[]
+            {
+                new ColumnDefinition("Wix4TouchFile", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Identifier, description: "Identifier for the Wix4TouchFile row in the package.", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("Component_", ColumnType.String, 72, primaryKey: false, nullable: false, ColumnCategory.Identifier, keyTable: "Component", keyColumn: 1, description: "Foreign key into the Component table used to determine install state", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("Path", ColumnType.String, 255, primaryKey: false, nullable: false, ColumnCategory.Formatted, description: "Formatted column that resolves to the path to touch.", modularizeType: ColumnModularizeType.Property),
+                new ColumnDefinition("Attributes", ColumnType.Number, 2, primaryKey: false, nullable: false, ColumnCategory.Unknown, minValue: 1, maxValue: 63, description: "1 == Touch only when the associated component is being installed, 2 == Touch only when the associated component is being repaired , 4 == Touch only when the associated component is being removed, 16 = path is in 64-bit location, 32 = touching the file is vital."),
+            },
+            symbolIdIsPrimaryKey: true
+        );
+
+        public static readonly TableDefinition Wix4User = new TableDefinition(
+            "Wix4User",
+            UtilSymbolDefinitions.User,
+            new[]
+            {
+                new ColumnDefinition("Wix4User", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Identifier, description: "Primary key, non-localized token", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("Component_", ColumnType.String, 72, primaryKey: false, nullable: true, ColumnCategory.Text, keyTable: "Component", keyColumn: 1, description: "Foreign key, Component used to determine install state", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("Name", ColumnType.String, 255, primaryKey: false, nullable: false, ColumnCategory.Formatted, description: "User name", modularizeType: ColumnModularizeType.Property),
+                new ColumnDefinition("Domain", ColumnType.String, 255, primaryKey: false, nullable: true, ColumnCategory.Formatted, description: "User domain", modularizeType: ColumnModularizeType.Property),
+                new ColumnDefinition("Password", ColumnType.String, 255, primaryKey: false, nullable: true, ColumnCategory.Formatted, description: "User password", modularizeType: ColumnModularizeType.Property),
+                new ColumnDefinition("Attributes", ColumnType.Number, 4, primaryKey: false, nullable: true, ColumnCategory.Unknown, minValue: 0, maxValue: 65535, description: "Attributes describing how to create the user"),
+            },
+            symbolIdIsPrimaryKey: true
+        );
+
+        public static readonly TableDefinition Wix4UserGroup = new TableDefinition(
+            "Wix4UserGroup",
+            UtilSymbolDefinitions.UserGroup,
+            new[]
+            {
+                new ColumnDefinition("Wix4User_", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Identifier, keyTable: "Wix4User", keyColumn: 1, description: "User to be joined to a Group.", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("Wix4Group_", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Identifier, keyTable: "Wix4Group", keyColumn: 1, description: "Group to join User to.", modularizeType: ColumnModularizeType.Column),
+            },
+            symbolIdIsPrimaryKey: false
+        );
+
+        public static readonly TableDefinition Wix4XmlFile = new TableDefinition(
+            "Wix4XmlFile",
+            UtilSymbolDefinitions.XmlFile,
+            new[]
+            {
+                new ColumnDefinition("Wix4XmlFile", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Identifier, description: "Primary key, non-localized token.", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("File", ColumnType.Localized, 255, primaryKey: false, nullable: false, ColumnCategory.Formatted, description: "The .XML file in which to write the information", modularizeType: ColumnModularizeType.Property),
+                new ColumnDefinition("ElementPath", ColumnType.Localized, 0, primaryKey: false, nullable: false, ColumnCategory.Formatted, description: "The .XML file element to modify.", modularizeType: ColumnModularizeType.Property),
+                new ColumnDefinition("Name", ColumnType.Localized, 255, primaryKey: false, nullable: true, ColumnCategory.Formatted, description: "The .XML file node to set/add in the element.", modularizeType: ColumnModularizeType.Property),
+                new ColumnDefinition("Value", ColumnType.Localized, 0, primaryKey: false, nullable: true, ColumnCategory.Formatted, description: "The value to be written.", modularizeType: ColumnModularizeType.Property),
+                new ColumnDefinition("Flags", ColumnType.Number, 4, primaryKey: false, nullable: false, ColumnCategory.Unknown, minValue: 0, maxValue: 70143, description: "Flags"),
+                new ColumnDefinition("Component_", ColumnType.String, 72, primaryKey: false, nullable: false, ColumnCategory.Identifier, keyTable: "Component", keyColumn: 1, description: "Foreign key into the Component table referencing component that controls the installing of the .XML value.", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("Sequence", ColumnType.Number, 2, primaryKey: false, nullable: true, ColumnCategory.Unknown, description: "Order to execute the XML modifications."),
+            },
+            symbolIdIsPrimaryKey: true
+        );
+
+        public static readonly TableDefinition Wix4XmlConfig = new TableDefinition(
+            "Wix4XmlConfig",
+            UtilSymbolDefinitions.XmlConfig,
+            new[]
+            {
+                new ColumnDefinition("Wix4XmlConfig", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Identifier, description: "Primary key, non-localized token.", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("File", ColumnType.Localized, 255, primaryKey: false, nullable: false, ColumnCategory.Formatted, description: "The .XML file in which to write the information", modularizeType: ColumnModularizeType.Property),
+                new ColumnDefinition("ElementId", ColumnType.String, 0, primaryKey: false, nullable: true, ColumnCategory.Identifier, keyTable: "Wix4XmlConfig", keyColumn: 1, description: "A foreign key reference to another Wix4XmlConfig row if no attributes are set and the row referenced is a create element row.", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("ElementPath", ColumnType.Localized, 0, primaryKey: false, nullable: true, ColumnCategory.Formatted, description: "The XPATH query for an element to modify or add children to. Must be null if ElementId is provided", modularizeType: ColumnModularizeType.Property),
+                new ColumnDefinition("VerifyPath", ColumnType.Localized, 0, primaryKey: false, nullable: true, ColumnCategory.Formatted, description: "The XPATH query run from ElementPath to verify whether a repair is necessary.  Also used to uninstall.", modularizeType: ColumnModularizeType.Property),
+                new ColumnDefinition("Name", ColumnType.Localized, 255, primaryKey: false, nullable: true, ColumnCategory.Formatted, description: "The .XML file node to set/add in the element.", modularizeType: ColumnModularizeType.Property),
+                new ColumnDefinition("Value", ColumnType.Localized, 0, primaryKey: false, nullable: true, ColumnCategory.Formatted, description: "The value to be written.", modularizeType: ColumnModularizeType.Property),
+                new ColumnDefinition("Flags", ColumnType.Number, 4, primaryKey: false, nullable: false, ColumnCategory.Unknown, minValue: 0, maxValue: 65536, description: "Element=1,Value=2,Document=4,Create=16,Delete=32,Install=256,Uninstall=512"),
+                new ColumnDefinition("Component_", ColumnType.String, 72, primaryKey: false, nullable: false, ColumnCategory.Identifier, keyTable: "Component", keyColumn: 1, description: "Foreign key into the Component table referencing component that controls the installing of the .XML value.", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("Sequence", ColumnType.Number, 2, primaryKey: false, nullable: true, ColumnCategory.Unknown, description: "Order to execute the XML modifications."),
+            },
+            symbolIdIsPrimaryKey: true
+        );
+
+        public static readonly TableDefinition Wix4FormatFile = new TableDefinition(
+            "Wix4FormatFile",
+            UtilSymbolDefinitions.WixFormatFiles,
+            new[]
+            {
+                new ColumnDefinition("Binary_", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Identifier, keyTable: "Binary", keyColumn: 1, description: "Binary data to be formatted.", modularizeType: ColumnModularizeType.Column),
+                new ColumnDefinition("File_", ColumnType.String, 72, primaryKey: true, nullable: false, ColumnCategory.Identifier, keyTable: "File", keyColumn: 1, description: "File whose component controls the custom action and where the formatted data is written.", modularizeType: ColumnModularizeType.Column),
+            },
+            symbolIdIsPrimaryKey: false
+        );
+
+        public static readonly TableDefinition[] All = new[]
+        {
+            Wix4CloseApplication,
+            Wix4RemoveFolderEx,
+            Wix4RemoveRegistryKeyEx,
+            Wix4RestartResource,
+            Wix4FileShare,
+            Wix4FileSharePermissions,
+            Wix4Group,
+            Wix4InternetShortcut,
+            Wix4PerformanceCategory,
+            Wix4Perfmon,
+            Wix4PerfmonManifest,
+            Wix4EventManifest,
+            Wix4SecureObject,
+            Wix4ServiceConfig,
+            Wix4TouchFile,
+            Wix4User,
+            Wix4UserGroup,
+            Wix4XmlFile,
+            Wix4XmlConfig,
+            Wix4FormatFile,
+        };
+    }
+}
diff --git a/src/ext/Util/wixext/UtilWarnings.cs b/src/ext/Util/wixext/UtilWarnings.cs
new file mode 100644
index 00000000..b65abe45
--- /dev/null
+++ b/src/ext/Util/wixext/UtilWarnings.cs
@@ -0,0 +1,37 @@
+// 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.Util
+{
+    using System;
+    using System.Resources;
+    using WixToolset.Data;
+
+    public static class UtilWarnings
+    {
+        public static Message DeprecatedPerfCounterElement(SourceLineNumber sourceLineNumbers)
+        {
+            return Message(sourceLineNumbers, Ids.DeprecatedPerfCounterElement, "The PerfCounter element has been deprecated.  Please use the PerformanceCounter element instead.");
+        }
+
+        public static Message RequiredAttributeForWindowsXP(SourceLineNumber sourceLineNumbers, string elementName, string attributeName)
+        {
+            return Message(sourceLineNumbers, Ids.RequiredAttributeForWindowsXP, "The {0}/@{1} attribute must be specified to successfully install on Windows XP.  You can ignore this warning if this installation does not install on Windows XP.", elementName, attributeName);
+        }
+
+        private static Message Message(SourceLineNumber sourceLineNumber, Ids id, string format, params object[] args)
+        {
+            return new Message(sourceLineNumber, MessageLevel.Warning, (int)id, format, args);
+        }
+
+        private static Message Message(SourceLineNumber sourceLineNumber, Ids id, ResourceManager resourceManager, string resourceName, params object[] args)
+        {
+            return new Message(sourceLineNumber, MessageLevel.Warning, (int)id, resourceManager, resourceName, args);
+        }
+
+        public enum Ids
+        {
+            DeprecatedPerfCounterElement = 5153,
+            RequiredAttributeForWindowsXP = 5154,
+        }
+    }
+}
diff --git a/src/ext/Util/wixext/UtilWindowsInstallerBackendExtension.cs b/src/ext/Util/wixext/UtilWindowsInstallerBackendExtension.cs
new file mode 100644
index 00000000..bca7c700
--- /dev/null
+++ b/src/ext/Util/wixext/UtilWindowsInstallerBackendExtension.cs
@@ -0,0 +1,13 @@
+// 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.Util
+{
+    using System.Collections.Generic;
+    using WixToolset.Data.WindowsInstaller;
+    using WixToolset.Extensibility;
+
+    public class UtilWindowsInstallerBackendBinderExtension : BaseWindowsInstallerBackendBinderExtension
+    {
+        public override IReadOnlyCollection<TableDefinition> TableDefinitions => UtilTableDefinitions.All;
+    }
+}
diff --git a/src/ext/Util/wixext/WixToolset.Util.wixext.csproj b/src/ext/Util/wixext/WixToolset.Util.wixext.csproj
new file mode 100644
index 00000000..10fc569e
--- /dev/null
+++ b/src/ext/Util/wixext/WixToolset.Util.wixext.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>netstandard2.0</TargetFramework>
+    <RootNamespace>WixToolset.Util</RootNamespace>
+    <Description>WiX Toolset Utility Extension</Description>
+    <Title>WiX Toolset Util Extension</Title>
+    <DebugType>embedded</DebugType>
+    <IncludeSymbols>true</IncludeSymbols>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <EmbeddedResource Include="$(OutputPath)..\util.wixlib" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\wixlib\util.wixproj" ReferenceOutputAssembly="false" Condition=" '$(NCrunch)'=='' " />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="WixToolset.Data" Version="4.0.*" />
+    <PackageReference Include="WixToolset.Extensibility" Version="4.0.*" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="all" />
+    <PackageReference Include="Nerdbank.GitVersioning" Version="3.3.37" PrivateAssets="All" />
+  </ItemGroup>
+</Project>
diff --git a/src/ext/Util/wixext/WixToolset.Util.wixext.nuspec b/src/ext/Util/wixext/WixToolset.Util.wixext.nuspec
new file mode 100644
index 00000000..ba3eaade
--- /dev/null
+++ b/src/ext/Util/wixext/WixToolset.Util.wixext.nuspec
@@ -0,0 +1,25 @@
+<?xml version="1.0"?>
+<package xmlns="http://schemas.microsoft.com/packaging/2010/07/nuspec.xsd">
+  <metadata minClientVersion="4.0">
+    <id>$id$</id>
+    <version>$version$</version>
+    <title>$title$</title>
+    <description>$description$</description>
+    <authors>$authors$</authors>
+    <license type="expression">MS-RL</license>
+    <requireLicenseAcceptance>false</requireLicenseAcceptance>
+    <copyright>$copyright$</copyright>
+    <projectUrl>$projectUrl$</projectUrl>
+    <repository type="$repositorytype$" url="$repositoryurl$" commit="$repositorycommit$" />
+  </metadata>
+
+  <files>
+    <file src="$projectFolder$$id$.targets" target="build" />
+
+    <file src="netstandard2.0\$id$.dll" target="tools" />
+
+    <file src="ARM64\*.pdb" target="pdbs\ARM64" />
+    <file src="x86\*.pdb" target="pdbs\x86" />
+    <file src="x64\*.pdb" target="pdbs\x64" />
+  </files>
+</package>
diff --git a/src/ext/Util/wixext/WixToolset.Util.wixext.targets b/src/ext/Util/wixext/WixToolset.Util.wixext.targets
new file mode 100644
index 00000000..64dff429
--- /dev/null
+++ b/src/ext/Util/wixext/WixToolset.Util.wixext.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>
+    <WixToolsetUtilWixextPath Condition=" '$(WixToolsetUtilWixextPath)' == '' ">$(MSBuildThisFileDirectory)..\tools\WixToolset.Util.wixext.dll</WixToolsetUtilWixextPath>
+  </PropertyGroup>
+  <ItemGroup>
+    <WixExtension Include="$(WixToolsetUtilWixextPath)" />
+  </ItemGroup>
+</Project>
diff --git a/src/ext/Util/wixext/WixToolset.Util.wixext.v3.ncrunchproject b/src/ext/Util/wixext/WixToolset.Util.wixext.v3.ncrunchproject
new file mode 100644
index 00000000..d75e7ab3
--- /dev/null
+++ b/src/ext/Util/wixext/WixToolset.Util.wixext.v3.ncrunchproject
@@ -0,0 +1,7 @@
+<ProjectConfiguration>
+  <Settings>
+    <AdditionalFilesToIncludeForProject>
+      <Value>..\..\build\Debug\util.wixlib</Value>
+    </AdditionalFilesToIncludeForProject>
+  </Settings>
+</ProjectConfiguration>
\ No newline at end of file