Bump version

* Small model updates, mainly documentation. Not essential.

* wrong branch lol

.github/workflows/build_and_test.yml

@@ -1,4 +1,4 @@
-name: Nuget Pack
+name: Build and Test
 
 on:
   push:
@@ -16,25 +16,22 @@ jobs:
     - name: Setup .NET
       uses: actions/setup-dotnet@v4
       with:
-        dotnet-version: 9.0.x
+        dotnet-version: |
+            6.0.x
+            8.0.x
+            9.0.x
         
-    - name: Restore dependencies
-      run: dotnet restore
-      
-    - name: Pack
-      run: dotnet pack
+    - name: Run tests
+      run: dotnet test
 
-    - name: Upload build
-      uses: actions/upload-artifact@v4
-      with:
-        name: 'Nuget Package'
-        path: 'SabreTools.Models/bin/Release/*.nupkg'
+    - name: Run publish script
+      run: ./publish-nix.sh
 
     - name: Upload to rolling
       uses: ncipollo/release-action@v1.14.0
       with:
         allowUpdates: True
-        artifacts: 'SabreTools.Models/bin/Release/*.nupkg'
+        artifacts: "*.nupkg,*.snupkg"
         body: 'Last built commit: ${{ github.sha }}'
         name: 'Rolling Release'
         prerelease: True

.github/workflows/check_pr.yml

@@ -11,7 +11,13 @@ jobs:
     - name: Setup .NET
       uses: actions/setup-dotnet@v4
       with:
-        dotnet-version: 9.0.x
+        dotnet-version: |
+            6.0.x
+            8.0.x
+            9.0.x
       
     - name: Build
-      run: dotnet build
+      run: dotnet build
+
+    - name: Run tests
+      run: dotnet test

LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2018-2025 Matt Nadareski
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice (including the next paragraph) shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.MD

@@ -1,13 +1,64 @@
 # SabreTools.Models
 
+[![Build and Test](https://github.com/SabreTools/SabreTools.Models/actions/workflows/build_and_test.yml/badge.svg?branch=main)](https://github.com/SabreTools/SabreTools.Models/actions/workflows/build_and_test.yml)
+
 This library comprises of models that represent either directly serializable or representative structures for all SabreTools projects. All of the main models representing metadata files should have parsers created outside of the current code.
 
 Find the link to the Nuget package [here](https://www.nuget.org/packages/SabreTools.Models).
 
-## Missing Metadata Models
+## Releases
 
-The following metadata file formats do not have models included in this library yet and, as such, do not have serializers:
+For the most recent stable build, download the latest release here: [Releases Page](https://github.com/SabreTools/SabreTools.Models/releases)
 
-- Missfile
-- SabreJSON
-- SabreDAT XML
+For the latest WIP build here: [Rolling Release](https://github.com/SabreTools/SabreTools.Models/releases/rolling)
+
+## Notable Information Sources
+
+Not all of this information was able to be gathered directly from the files in question, so here is a non-exhaustive list of sites and projects that allow this project to exist. Most of the models also have direct links to specific pages or code snippets, where available.
+
+| Site/Project | Models Directory |
+| --- | --- |
+| [3DBrew](https://www.3dbrew.org/wiki/Main_Page) | N3DS |
+| [Aaru Data Preservation Suite](https://github.com/aaru-dps) | PIC |
+| [Advanced Access Content System Licensing Administrator (AACS LA)](https://aacsla.com/) | AACS |
+| [BYTE*](https://web.archive.org/web/20240703222951/https://bytepointer.com/index.htm) | NewExecutable |
+| [cabextract/libmspack](https://www.cabextract.org.uk/) | LZ |
+| [DBox](https://dbox.tools/) | Xbox |
+| [DebugInfo.com](https://www.debuginfo.com/index.html) | PortableExecutable |
+| [Devilsclaw](https://devilsclaws.net/) | PFF |
+| [DSiBrew](https://dsibrew.org/wiki/Main_Page) | Nitro |
+| [DVD Resources for Open Source Development](https://dvd.sourceforge.net/) | DVD |
+| [EDM/2](https://www.edm2.com/index.php/Main_Page) | LinearExecutable |
+| [faydoc.tripod.com](https://faydoc.tripod.com/formats/) | LinearExecutable |
+| [GuitarGame_ChartFormats](https://github.com/TheNathannator/GuitarGame_ChartFormats/) | Charts |
+| [HandWiki](https://handwiki.org/wiki/Start) | Quantum |
+| [HLLib](https://github.com/RavuAlHemio/hllib/) | BSP, GCF, NCF, PAK, SGA, VPK, WAD3, XZP |
+| [IBM Documentation](https://www.ibm.com/docs/en) | TAR |
+| [IETF](https://www.ietf.org/) | GZIP |
+| [Independent Commodore Library](https://petlibrary.tripod.com/) | PKZIP |
+| [Ladislav Zezula](http://zezula.net/en/tools/main.html) | MoPaQ |
+| [libaacs](https://code.videolan.org/videolan/libaacs/) | AACS |
+| [libbdplus](https://github.com/mwgoldsmith/bdplus) | BD+ |
+| [libexe](https://github.com/libyal/libexe/) | NewExecutable |
+| [MAME](https://github.com/mamedev/mame/) | CHD |
+| [Matthew Russotto](http://www.russotto.net/quantumcomp.html) | Compression/Quantum |
+| [Microsoft Learn](https://learn.microsoft.com/en-us/) | BMP, CFB, Compression/LZX, Compression/MSZIP, MicrosoftCabinet, OLE, PortableExecutable, SecuROM, WiseInstaller |
+| [msitools](https://github.com/GNOME/msitools/) | CFB |
+| [OSDev.org](https://wiki.osdev.org/Expanded_Main_Page) | MSDOS, NewExecutable |
+| [PInvoke.net](http://www.pinvoke.net/index.aspx) | MSDOS |
+| [PKWARE(?)](https://pkware.cachefly.net/webdocs/casestudies/APPNOTE.TXT) | PKZIP |
+| [PS3 Developer Wiki](https://www.psdevwiki.com/ps3/) | IRD, PlayStation3 |
+| [RanseiLink](https://github.com/Deijin27/RanseiLink) | Nitro |
+| [Reverse Engineering Wise](https://codeberg.org/CYBERDEV/REWise) | WiseInstaller |
+| [SharpCompress](https://github.com/adamhathcock/sharpcompress) | PKZIP |
+| [Source SDK 2013](https://github.com/ValveSoftware/source-sdk-2013) | BSP |
+| [Technical Committee T10](https://www.t10.org/) | PIC |
+| [The Go tools for Windows + Assembler](https://www.godevtool.com/) | PortableExecutable |
+| [The Whole Half-Life](https://twhl.info/wiki/page/Specification:_WAD3) | WAD3 |
+| [Unshield](https://github.com/twogood/unshield) | InstallShieldCabinet |
+| [unshieldv3](https://github.com/wfr/unshieldv3) | InstallShieldArchiveV3 |
+| [Valve Developer Community](https://developer.valvesoftware.com/wiki/Main_Page) | BSP, VPK |
+| [w4kfu's bl0g](https://web.archive.org/web/20250206143756/http://blog.w4kfu.com/) | SafeDisc |
+| [Wine](https://github.com/wine-mirror/wine/) | LZ |
+| [XboxDevWiki.net](https://xboxdevwiki.net/Main_Page) | Xbox |
+| [XeNTaX Game Research Forum](http://web.archive.org/web/20231031162306/https://forum.xentax.com/) | SFFS |

SabreTools.Models/AACS/CopyrightRecord.cs

@@ -5,7 +5,6 @@ namespace SabreTools.Models.AACS
     /// <summary>
     /// This record type is undocumented but found in real media key blocks
     /// </summary>
-    [StructLayout(LayoutKind.Sequential)]
     public sealed class CopyrightRecord : Record
     {
         /// <summary>

SabreTools.Models/AACS/DriveRevocationListRecord.cs

@@ -21,6 +21,6 @@ namespace SabreTools.Models.AACS
         /// <summary>
         /// Revocation list entries
         /// </summary>
-        public DriveRevocationSignatureBlock?[]? SignatureBlocks { get; set; }
+        public DriveRevocationSignatureBlock[]? SignatureBlocks { get; set; }
     }
 }

SabreTools.Models/AACS/DriveRevocationSignatureBlock.cs

@@ -12,6 +12,6 @@ namespace SabreTools.Models.AACS
         /// A list of 8-byte Host Drive List Entry fields, the length of this
         /// list being equal to the number in the signature block.
         /// </summary>
-        public DriveRevocationListEntry?[]? EntryFields { get; set; }
+        public DriveRevocationListEntry[]? EntryFields { get; set; }
     }
 }

SabreTools.Models/AACS/Enums.cs

@@ -27,6 +27,20 @@ namespace SabreTools.Models.AACS
         /// Section 3.2.5.2, which are only processed by Class II Licensed Products.
         /// </summary>
         Type10 = 0x000A1003,
+
+        /// <summary>
+        /// Type 2.0 Category C.
+        /// This is the Media Key Block Type found on "UHD" media (AACS v2.0)
+        /// </summary>
+        /// <see href="https://code.videolan.org/videolan/libaacs/-/blob/master/src/libaacs/mkb.h"/>
+        Type20 = 0x48141003,
+
+        /// <summary>
+        /// Type 2.1 Category C.
+        /// This is the Media Key Block Type found on "UHD" media (AACS v2.1)
+        /// </summary>
+        /// <see href="https://code.videolan.org/videolan/libaacs/-/blob/master/src/libaacs/mkb.h"/>
+        Type21 = 0x48151003,
     }
 
     public enum RecordType : byte
@@ -35,6 +49,7 @@ namespace SabreTools.Models.AACS
         ExplicitSubsetDifference = 0x04,
         MediaKeyData = 0x05,
         SubsetDifferenceIndex = 0x07,
+        MediaKeyVariantData = 0x0C,
         TypeAndVersion = 0x10,
         DriveRevocationList = 0x20,
         HostRevocationList = 0x21,
@@ -42,5 +57,13 @@ namespace SabreTools.Models.AACS
 
         // Not documented
         Copyright = 0x7F,
+
+        // Record types only found in UHD media (AACS v2)
+        // <see href="https://code.videolan.org/videolan/libaacs/-/blob/master/src/devtools/mkb_dump.c"/>
+        Unknown0x28_AACS2 = 0x28,
+        DriveRevocationList_AACS2 = 0x30,
+        HostRevocationList_AACS2 = 0x31,
+        VerifyMediaKey_AACS2 = 0x86,
+        EmptyRecord0xF8_AACS2 = 0xF8,
     }
 }

SabreTools.Models/AACS/ExplicitSubsetDifferenceRecord.cs

@@ -6,6 +6,6 @@ namespace SabreTools.Models.AACS
         /// <summary>
         /// In this record, each subset-difference is encoded with 5 bytes.
         /// </summary>
-        public SubsetDifference?[]? SubsetDifferences { get; set; }
+        public SubsetDifference[]? SubsetDifferences { get; set; }
     }
 }

SabreTools.Models/AACS/GenericRecord.cs

@@ -0,0 +1,13 @@
+namespace SabreTools.Models.AACS
+{
+    /// <summary>
+    /// This represents any record that does not have a concrete model yet
+    /// </summary>
+    public sealed class GenericRecord : Record
+    {
+        /// <summary>
+        /// Unparsed data comprising the record after the header
+        /// </summary>
+        public byte[]? Data { get; set; }
+    }
+}

SabreTools.Models/AACS/HostRevocationListRecord.cs

@@ -24,6 +24,6 @@ namespace SabreTools.Models.AACS
         /// <summary>
         /// Revocation list entries
         /// </summary>
-        public HostRevocationSignatureBlock?[]? SignatureBlocks { get; set; }
+        public HostRevocationSignatureBlock[]? SignatureBlocks { get; set; }
     }
 }

SabreTools.Models/AACS/HostRevocationSignatureBlock.cs

@@ -12,6 +12,6 @@ namespace SabreTools.Models.AACS
         /// A list of 8-byte Host Revocation List Entry fields, the length of this
         /// list being equal to the number in the signature block.
         /// </summary>
-        public HostRevocationListEntry?[]? EntryFields { get; set; }
+        public HostRevocationListEntry[]? EntryFields { get; set; }
     }
 }

SabreTools.Models/AACS/MediaKeyBlock.cs

@@ -9,6 +9,6 @@ namespace SabreTools.Models.AACS
         /// <summary>
         /// Records
         /// </summary>
-        public Record?[]? Records { get; set; }
+        public Record[]? Records { get; set; }
     }
 }

SabreTools.Models/ArchiveDotOrg/Files.cs

@@ -7,6 +7,6 @@ namespace SabreTools.Models.ArchiveDotOrg
     public class Files
     {
         [XmlElement("file")]
-        public File?[]? File { get; set; }
+        public File[]? File { get; set; }
     }
 }

SabreTools.Models/AttractMode/MetadataFile.cs

@@ -8,6 +8,6 @@ namespace SabreTools.Models.AttractMode
         [Required]
         public string[]? Header { get; set; }
 
-        public Row?[]? Row { get; set; }
+        public Row[]? Row { get; set; }
     }
 }

SabreTools.Models/BDPlus/Constants.cs

@@ -2,6 +2,8 @@ namespace SabreTools.Models.BDPlus
 {
     public static class Constants
     {
+        public static readonly byte[] SignatureBytes = [0x42, 0x44, 0x53, 0x56, 0x4D, 0x5F, 0x43, 0x43];
+
         public const string SignatureString = "BDSVM_CC";
     }
 }

SabreTools.Models/BDPlus/SVM.cs

@@ -1,3 +1,5 @@
+using System.Runtime.InteropServices;
+
 namespace SabreTools.Models.BDPlus
 {
     /// <see href="https://github.com/mwgoldsmith/bdplus/blob/master/src/libbdplus/bdsvm/loader.c"/>
@@ -6,40 +8,39 @@ namespace SabreTools.Models.BDPlus
         /// <summary>
         /// "BDSVM_CC"
         /// </summary>
-        /// <remarks>8 bytes</remarks>
-        public string? Signature { get; set; }
+        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 8)]
+        public string? Signature;
 
         /// <summary>
         /// Unknown data
         /// </summary>
-        /// <remarks>5 bytes</remarks>
-        public byte[]? Unknown1 { get; set; }
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = 5)]
+        public byte[]? Unknown1 = new byte[5];
 
         /// <summary>
         /// Version year
         /// </summary>
-        public ushort Year { get; set; }
+        public ushort Year;
 
         /// <summary>
         /// Version month
         /// </summary>
-        public byte Month { get; set; }
+        public byte Month;
 
         /// <summary>
         /// Version day
         /// </summary>
-        public byte Day { get; set; }
+        public byte Day;
 
         /// <summary>
         /// Unknown data
         /// </summary>
-        /// <remarks>4 bytes</remarks>
-        public byte[]? Unknown2 { get; set; }
+        public uint Unknown2;
 
         /// <summary>
         /// Length
         /// </summary>
-        public uint Length { get; set; }
+        public uint Length;
 
         /// <summary>
         /// Length bytes of data

SabreTools.Models/BSP/BspFile.cs

@@ -34,6 +34,11 @@ namespace SabreTools.Models.BSP
         /// </summary>
         public VerticesLump? VerticesLump { get; set; }
 
+        /// <summary>
+        /// LUMP_VISIBILITY [4]
+        /// </summary>
+        public VisibilityLump? VisibilityLump { get; set; }
+
         /// <summary>
         /// LUMP_NODES [5]
         /// </summary>

SabreTools.Models/BSP/BspHeader.cs

@@ -17,6 +17,7 @@ namespace SabreTools.Models.BSP
         /// Lumps
         /// </summary>
         /// <remarks>15 entries</remarks>
-        public BspLumpEntry[]? Lumps { get; set; }
+        [MarshalAs(UnmanagedType.ByValArray, SizeConst = Constants.BSP_HEADER_LUMPS)]
+        public BspLumpEntry[]? Lumps;
     }
 }

SabreTools.Models/BSP/BspModel.cs

@@ -27,17 +27,17 @@ namespace SabreTools.Models.BSP
         /// <summary>
         /// Defines bounding box
         /// </summary>
-        public Vector3D Mins;
+        public Vector3D? Mins;
 
         /// <summary>
         /// Defines bounding box
         /// </summary>
-        public Vector3D Maxs;
+        public Vector3D? Maxs;
 
         /// <summary>
         /// Coordinates to move the coordinate system
         /// </summary>
-        public Vector3D OriginVector;
+        public Vector3D? OriginVector;
 
         /// <summary>
         /// Index into nodes array

SabreTools.Models/BSP/BspTexinfo.cs

@@ -22,7 +22,7 @@ namespace SabreTools.Models.BSP
         /// <summary>
         /// S-vector
         /// </summary>
-        public Vector3D SVector;
+        public Vector3D? SVector;
 
         /// <summary>
         /// Texture shift in the S direction
@@ -32,7 +32,7 @@ namespace SabreTools.Models.BSP
         /// <summary>
         /// T-vector
         /// </summary>
-        public Vector3D TVector;
+        public Vector3D? TVector;
 
         /// <summary>
         /// Texture shift in the T direction

SabreTools.Models/BSP/ColorRGBExp32.cs

@@ -7,7 +7,7 @@ namespace SabreTools.Models.BSP
     /// </summary>
     /// <see href="https://developer.valvesoftware.com/wiki/BSP_(Source)"/> 
     [StructLayout(LayoutKind.Sequential)]
-    public struct ColorRGBExp32
+    public class ColorRGBExp32
     {
         public byte Red;
 

SabreTools.Models/BSP/CompressedLightCube.cs

@@ -8,7 +8,7 @@ namespace SabreTools.Models.BSP
     /// </summary>
     /// <see href="https://developer.valvesoftware.com/wiki/BSP_(Source)"/> 
     [StructLayout(LayoutKind.Sequential)]
-    public struct CompressedLightCube
+    public class CompressedLightCube
     {
         [MarshalAs(UnmanagedType.ByValArray, SizeConst = 6)]
         public ColorRGBExp32[]? Colors;

SabreTools.Models/BSP/DispInfo.cs

@@ -25,7 +25,7 @@ namespace SabreTools.Models.BSP
         /// <summary>
         /// Start position used for orientation
         /// </summary>
-        public Vector3D startPosition;
+        public Vector3D? StartPosition;
 
         /// <summary>
         /// Index into LUMP_DISP_VERTS.

SabreTools.Models/BSP/DispVert.cs

@@ -18,7 +18,7 @@ namespace SabreTools.Models.BSP
         /// <summary>
         /// Vector field defining displacement volume.
         /// </summary>
-        public Vector3D Vec;
+        public Vector3D? Vec;
 
         /// <summary>
         /// Displacement distances.

SabreTools.Models/BSP/LeafAmbientLighting.cs

@@ -16,7 +16,7 @@ namespace SabreTools.Models.BSP
     [StructLayout(LayoutKind.Sequential)]
     public sealed class LeafAmbientLighting
     {
-        public CompressedLightCube Cube;
+        public CompressedLightCube? Cube;
 
         /// <summary>
         /// Fixed point fraction of leaf bounds

SabreTools.Models/BSP/LightmapLump.cs

@@ -13,6 +13,6 @@ namespace SabreTools.Models.BSP
         /// Lightmap RGB values
         /// </summary>
         /// <remarks>Array of 3-byte values</remarks>
-        public byte[,]? Lightmap { get; set; }
+        public byte[][]? Lightmap { get; set; }
     }
 }

SabreTools.Models/BSP/OccluderData.cs

@@ -27,12 +27,12 @@ namespace SabreTools.Models.BSP
         /// <summary>
         /// Minima of all vertices
         /// </summary>
-        public Vector3D Mins;
+        public Vector3D? Mins;
 
         /// <summary>
         /// Maxima of all vertices
         /// </summary>
-        public Vector3D Maxs;
+        public Vector3D? Maxs;
 
         /// <remarks>Since v1</remarks>
         public int Area;

SabreTools.Models/BSP/OcclusionLump.cs

@@ -41,6 +41,6 @@ namespace SabreTools.Models.BSP
         /// <summary>
         /// <see cref="VertexIndexCount">
         /// </summary>
-        public int[]? VertexIndices;
+        public int[]? VertexIndicies;
     }
 }

SabreTools.Models/BSP/Overlay.cs

@@ -41,8 +41,8 @@ namespace SabreTools.Models.BSP
         [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
         public Vector3D[]? UVPoints = new Vector3D[4];
 
-        public Vector3D Origin;
+        public Vector3D? Origin;
 
-        public Vector3D BasisNormal;
+        public Vector3D? BasisNormal;
     }
 }

SabreTools.Models/BSP/PakfileLump.cs

@@ -0,0 +1,43 @@
+namespace SabreTools.Models.BSP
+{
+    /// <summary>
+    /// The Pakfile lump (Lump 40) is a special lump that can contains
+    /// multiple files which are embedded into the bsp file. Usually,
+    /// they contain special texture (.vtf) and material (.vmt) files
+    /// which are used to store the reflection maps from env_cubemap
+    /// entities in the map; these files are built and placed in the
+    /// Pakfile lump when the buildcubemaps console command is executed.
+    /// The Pakfile can optionally contain such things as custom textures
+    /// and prop models used in the map, and are placed into the bsp file
+    /// by using the BSPZIP program (or alternate programs such as Pakrat).
+    /// These files are integrated into the game engine's file system
+    /// and will be loaded preferentially before externally located
+    /// files are used.
+    /// 
+    /// The format of the Pakfile lump is identical to that used by the
+    /// Zip compression utility when no compression is specified (i.e.,
+    /// the individual files are stored in uncompressed format). In some
+    /// branches, such as , LZMA compression can be used as well. If the
+    /// Pakfile lump is extracted and written to a file, it can therefore
+    /// be opened with WinZip and similar programs.
+    /// 
+    /// The header public/zip_uncompressed.h defines the structures
+    /// present in the Pakfile lump. The last element in the lump is a
+    /// ZIP_EndOfCentralDirRecord structure. This points to an array of
+    /// ZIP_FileHeader structures immediately preceeding it, one for each
+    /// file present in the Pak. Each of these headers then point to
+    /// ZIP_LocalFileHeader structures that are followed by that file's
+    /// data. 
+    /// 
+    /// The Pakfile lump is usually the last element of the bsp file.
+    /// </summary>
+    /// <see href="https://developer.valvesoftware.com/wiki/BSP_(Source)"/> 
+    public sealed class PakfileLump
+    {
+        /// <summary>
+        /// Pakfile data
+        /// </summary>
+        /// TODO: Split and/or decompress data?
+        public byte[]? Data;
+    }
+}

SabreTools.Models/BSP/PhysCollideLump.cs

@@ -0,0 +1,11 @@
+namespace SabreTools.Models.BSP
+{
+    /// <see href="https://developer.valvesoftware.com/wiki/BSP_(Source)"/>
+    public sealed class PhysCollideLump : Lump
+    {
+        /// <summary>
+        /// Models
+        /// </summary>
+        public PhysModel[]? Models { get; set; }
+    }
+}

SabreTools.Models/BSP/PhysModel.cs

@@ -0,0 +1,42 @@
+using System.Runtime.InteropServices;
+
+namespace SabreTools.Models.BSP
+{
+    /// <summary>
+    /// The physcollide lump (Lump 29) contains physics data for the world.
+    /// </summary>
+    /// <see href="https://developer.valvesoftware.com/wiki/BSP_(Source)"/>
+    [StructLayout(LayoutKind.Sequential)]
+    public sealed class PhysModel
+    {
+        /// <summary>
+        /// Perhaps the index of the model to which this physics model applies?
+        /// </summary>
+        public int ModelIndex;
+
+        /// <summary>
+        /// Total size of the collision data sections
+        /// </summary>
+        public int DataSize;
+
+        /// <summary>
+        /// Size of the text section
+        /// </summary>
+        public int KeydataSize;
+
+        /// <summary>
+        /// Number of collision data sections
+        /// </summary>
+        public int SolidCount;
+
+        /// <summary>
+        /// Collision data of length <see cref="SolidCount"/> 
+        /// </summary>
+        public PhysSolid[]? Solids;
+
+        /// <summary>
+        /// Key data of size <see cref="KeydataSize"/> 
+        /// </summary>
+        public byte[]? TextData;
+    }
+}

SabreTools.Models/BSP/PhysSolid.cs

@@ -0,0 +1,25 @@
+using System.Runtime.InteropServices;
+
+namespace SabreTools.Models.BSP
+{
+    /// <summary>
+    /// The last two parts appear to be identical to the PHY file format,
+    /// which means their exact contents are unknown. Note that the
+    /// compactsurfaceheader_t structure contains the data size of each
+    /// collision data section (including the rest of the header)
+    /// </summary>
+    /// <see href="https://developer.valvesoftware.com/wiki/BSP_(Source)"/>
+    [StructLayout(LayoutKind.Sequential)]
+    public sealed class PhysSolid
+    {
+        /// <summary>
+        /// Size of the collision data
+        /// </summary>
+        public int Size;
+
+        /// <summary>
+        /// Collision data of length <see cref="Size"/> 
+        /// </summary>
+        public byte[]? CollisionData;
+    }
+}

SabreTools.Models/BSP/Plane.cs

@@ -25,7 +25,7 @@ namespace SabreTools.Models.BSP
         /// <summary>
         /// The planes normal vector
         /// </summary>
-        public Vector3D NormalVector;
+        public Vector3D? NormalVector;
 
         /// <summary>
         /// Plane equation is: vNormal * X = fDist

SabreTools.Models/BSP/QAngle.cs

@@ -8,10 +8,10 @@ namespace SabreTools.Models.BSP
     /// from the cardinal Z axis.
     /// </summary>
     [StructLayout(LayoutKind.Sequential)]
-    public struct QAngle
+    public class QAngle
     {
-        public float X { get; set; }
-        public float Y { get; set; }
-        public float Z { get; set; }
+        public float X;
+        public float Y;
+        public float Z;
     }
 }

SabreTools.Models/BSP/StaticPropDictLump.cs

@@ -19,6 +19,6 @@ namespace SabreTools.Models.BSP
         /// Model name
         /// </summary>
         /// <remarks>[dictEntries][128]</remarks>
-        public char[,]? Name;
+        public char[][]? Name;
     }
 }

SabreTools.Models/BSP/StaticPropLump.cs

@@ -39,12 +39,12 @@ namespace SabreTools.Models.BSP
         /// <summary>
         /// Origin
         /// </summary>
-        public Vector3D Origin;
+        public Vector3D? Origin;
 
         /// <summary>
         /// Orientation (pitch yaw roll)
         /// </summary>
-        public QAngle Angles;
+        public QAngle? Angles;
 
         #endregion
 
@@ -90,7 +90,7 @@ namespace SabreTools.Models.BSP
         /// <summary>
         /// For lighting
         /// </summary>
-        public Vector3D LightingOrigin;
+        public Vector3D? LightingOrigin;
 
         #endregion
 
@@ -151,7 +151,7 @@ namespace SabreTools.Models.BSP
         /// <summary>
         /// Per instance color and alpha modulation
         /// </summary>
-        public ColorRGBExp32 DiffuseModulation;
+        public ColorRGBExp32? DiffuseModulation;
 
         #endregion
 

SabreTools.Models/BSP/Texdata.cs

@@ -16,7 +16,7 @@ namespace SabreTools.Models.BSP
         /// <summary>
         /// RGB reflectivity
         /// </summary>
-        public Vector3D Reflectivity;
+        public Vector3D? Reflectivity;
 
         /// <summary>
         /// Index into TexdataStringTable

SabreTools.Models/BSP/VbspFile.cs

@@ -153,7 +153,7 @@ namespace SabreTools.Models.BSP
         /// <summary>
         /// LUMP_DISPINFO [26]
         /// </summary>
-        public DispInfosLump? DispInfoLump { get; set; }
+        public DispInfosLump? DispInfosLump { get; set; }
 
         /// <summary>
         /// LUMP_ORIGINALFACES [27]
@@ -166,8 +166,10 @@ namespace SabreTools.Models.BSP
         /// TODO: Find definition and implement
         // public PhysDispLump? PhysDispLump { get; set; }
 
-        // TODO: Implement Lump 29
-        // https://developer.valvesoftware.com/wiki/BSP_(Source)#Physics
+        /// <summary>
+        /// LUMP_PHYSCOLLIDE [29]
+        /// </summary>
+        public PhysCollideLump? PhysCollideLump { get; set; }
 
         /// <summary>
         /// LUMP_VERTNORMALS [30]
@@ -190,7 +192,7 @@ namespace SabreTools.Models.BSP
         /// <summary>
         /// LUMP_DISP_VERTS [33]
         /// </summary>
-        public DispVertsLump? DispVertLump { get; set; }
+        public DispVertsLump? DispVertsLump { get; set; }
 
         /// <summary>
         /// LUMP_DISP_LIGHTMAP_SAMPLE_POSITIONS [34]
@@ -227,8 +229,10 @@ namespace SabreTools.Models.BSP
         /// TODO: Find definition and implement
         // public PrimIndicesLump? PrimIndicesLump { get; set; }
 
-        // TODO: Implement Lump 40
-        // https://developer.valvesoftware.com/wiki/BSP_(Source)#Pakfile
+        /// <summary>
+        /// LUMP_PAKFILE [40]
+        /// </summary>
+        public PakfileLump? PakfileLump { get; set; }
 
         /// <summary>
         /// LUMP_CLIPPORTALVERTS [41]
@@ -239,7 +243,7 @@ namespace SabreTools.Models.BSP
         /// <summary>
         /// LUMP_CUBEMAPS [42]
         /// </summary>
-        public CubemapsLump? CubemapLump { get; set; }
+        public CubemapsLump? CubemapsLump { get; set; }
 
         /// <summary>
         /// LUMP_TEXDATA_STRING_DATA [43]
@@ -304,7 +308,7 @@ namespace SabreTools.Models.BSP
         /// <summary>
         /// LUMP_WORLDLIGHTS_HDR [54]
         /// </summary>
-        public WorldLightsLump? WorldLightsLump { get; set; }
+        public WorldLightsLump? HDRWorldLightsLump { get; set; }
 
         /// <summary>
         /// LUMP_LEAF_AMBIENT_LIGHTING_HDR [55]
@@ -353,7 +357,7 @@ namespace SabreTools.Models.BSP
         // public PhysLevelLump? PhysLevelLump { get; set; }
 
         /// <summary>
-        /// LUMP_DISP_MULTIBLEND [64]
+        /// LUMP_DISP_MULTIBLEND [63]
         /// </summary>
         /// TODO: Find definition and implement
         // public DispMultiBlendLump? DispMultiBlendLump { get; set; }

SabreTools.Models/BSP/VbspLeaf.cs

@@ -83,7 +83,7 @@ namespace SabreTools.Models.BSP
         /// <summary>
         /// Precaculated light info for entities.
         /// </summary>
-        public CompressedLightCube AmbientLighting;
+        public CompressedLightCube? AmbientLighting;
 
         #endregion
 

SabreTools.Models/BSP/VbspModel.cs

@@ -15,17 +15,17 @@ namespace SabreTools.Models.BSP
         /// <summary>
         /// Bounding box
         /// </summary>
-        public Vector3D Mins;
+        public Vector3D? Mins;
 
         /// <summary>
         /// Bounding box
         /// </summary>
-        public Vector3D Maxs;
+        public Vector3D? Maxs;
 
         /// <summary>
         /// For sounds or lights
         /// </summary>
-        public Vector3D OriginVector;
+        public Vector3D? OriginVector;
 
         /// <summary>
         /// Index into nodes

SabreTools.Models/BSP/VbspTexinfo.cs

@@ -22,7 +22,7 @@ namespace SabreTools.Models.BSP
         /// <summary>
         /// Texture S-vector
         /// </summary>
-        public Vector3D TextureSVector;
+        public Vector3D? TextureSVector;
 
         /// <summary>
         /// Texture shift in the S direction
@@ -32,7 +32,7 @@ namespace SabreTools.Models.BSP
         /// <summary>
         /// Texture T-vector
         /// </summary>
-        public Vector3D TextureTVector;
+        public Vector3D? TextureTVector;
 
         /// <summary>
         /// Texture shift in the T direction
@@ -42,7 +42,7 @@ namespace SabreTools.Models.BSP
         /// <summary>
         /// Lightmap S-vector
         /// </summary>
-        public Vector3D LightmapSVector;
+        public Vector3D? LightmapSVector;
 
         /// <summary>
         /// Lightmap shift in the S direction
@@ -52,7 +52,7 @@ namespace SabreTools.Models.BSP
         /// <summary>
         /// Lightmap T-vector
         /// </summary>
-        public Vector3D LightmapTVector;
+        public Vector3D? LightmapTVector;
 
         /// <summary>
         /// Lightmap shift in the T direction

SabreTools.Models/BSP/Vector3D.cs

@@ -8,10 +8,10 @@ namespace SabreTools.Models.BSP
     /// spec and the code of the hlbsp project.
     /// </summary>
     [StructLayout(LayoutKind.Sequential)]
-    public struct Vector3D
+    public class Vector3D
     {
-        public float X { get; set; }
-        public float Y { get; set; }
-        public float Z { get; set; }
+        public float X;
+        public float Y;
+        public float Z;
     }
 }

SabreTools.Models/BSP/VisibilityLump.cs

@@ -17,6 +17,6 @@ namespace SabreTools.Models.BSP
         public int NumClusters { get; set; }
 
         /// <remarks>[numclusters][2]</remarks>
-        public int[,]? ByteOffsets { get; set; }
+        public int[][]? ByteOffsets { get; set; }
     }
 }

SabreTools.Models/BSP/WorldLight.cs

@@ -14,14 +14,14 @@ namespace SabreTools.Models.BSP
     [StructLayout(LayoutKind.Sequential)]
     public sealed class WorldLight
     {
-        public Vector3D Origin;
+        public Vector3D? Origin;
 
-        public Vector3D Intensity;
+        public Vector3D? Intensity;
 
         /// <summary>
         /// For surfaces and spotlights
         /// </summary>
-        public Vector3D Normal;
+        public Vector3D? Normal;
 
         public int Cluster;
 

SabreTools.Models/BZip2/Archive.cs

@@ -0,0 +1,10 @@
+namespace SabreTools.Models.BZip2
+{
+    /// <summary>
+    /// This is a placeholder model for future work
+    /// </summary>
+    public class Archive
+    {
+
+    }
+}

SabreTools.Models/BZip2/Constants.cs

@@ -0,0 +1,9 @@
+namespace SabreTools.Models.BZip2
+{
+    public static class Constants
+    {
+        public static readonly byte[] SignatureBytes = [0x42, 0x52, 0x68];
+
+        public const string SignatureString = "BRh";
+    }
+}

SabreTools.Models/CFB/DirectoryEntry.cs

@@ -22,18 +22,18 @@ namespace SabreTools.Models.CFB
         [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
         public string? Name;
 
-        /// <summary>
-        /// This field MUST be 0x00, 0x01, 0x02, or 0x05, depending on the
-        /// actual type of object. All other values are not valid.
-        /// </summary>
-        public ushort NameLength;
-
         /// <summary>
         /// This field MUST match the length of the Directory Entry Name Unicode
         /// string in bytes. The length MUST be a multiple of 2 and include the
         /// terminating null character in the count. This length MUST NOT exceed 64,
         /// the maximum size of the Directory Entry Name field.
         /// </summary>
+        public ushort NameLength;
+
+        /// <summary>
+        /// This field MUST be 0x00, 0x01, 0x02, or 0x05, depending on the
+        /// actual type of object. All other values are not valid.
+        /// </summary>
         [MarshalAs(UnmanagedType.U1)]
         public ObjectType ObjectType;
 

SabreTools.Models/CHD/Constants.cs

@@ -2,6 +2,8 @@ namespace SabreTools.Models.CHD
 {
     public static class Constants
     {
+        public static readonly byte[] SignatureBytes = [0x4D, 0x43, 0x6F, 0x6D, 0x70, 0x72, 0x48, 0x44];
+
         public const string SignatureString = "MComprHD";
 
         #region Header Sizes

SabreTools.Models/COFF/Constants.cs

@@ -0,0 +1,20 @@
+namespace SabreTools.Models.COFF
+{
+    public static class Constants
+    {
+        /// <summary>
+        /// Fixed size of <see cref="FileHeader"/> 
+        /// </summary>
+        public const int FileHeaderSize = 20;
+
+        /// <summary>
+        /// Fixed size of <see cref="SectionHeader"/> 
+        /// </summary>
+        public const int SectionHeaderSize = 40;
+
+        /// <summary>
+        /// Fixed size of <see cref="SymbolTableEntries.BaseEntry"/> 
+        /// </summary>
+        public const int SymbolTableEntrySize = 18;
+    }
+}

SabreTools.Models/COFF/FileHeader.cs

@@ -1,6 +1,6 @@
 using System.Runtime.InteropServices;
 
-namespace SabreTools.Models.PortableExecutable
+namespace SabreTools.Models.COFF
 {
     /// <summary>
     /// At the beginning of an object file, or immediately after the signature
@@ -9,7 +9,7 @@ namespace SabreTools.Models.PortableExecutable
     /// </summary>
     /// <see href="https://learn.microsoft.com/en-us/windows/win32/debug/pe-format"/>
     [StructLayout(LayoutKind.Sequential)]
-    public sealed class COFFFileHeader
+    public sealed class FileHeader
     {
         /// <summary>
         /// The number that identifies the type of target machine.

SabreTools.Models/COFF/LineNumber.cs

@@ -1,6 +1,6 @@
 using System.Runtime.InteropServices;
 
-namespace SabreTools.Models.PortableExecutable
+namespace SabreTools.Models.COFF
 {
     /// <summary>
     /// COFF line numbers are no longer produced and, in the future, will
@@ -17,7 +17,7 @@ namespace SabreTools.Models.PortableExecutable
     /// </summary>
     /// <see href="https://learn.microsoft.com/en-us/windows/win32/debug/pe-format"/>
     [StructLayout(LayoutKind.Explicit)]
-    public sealed class COFFLineNumber
+    public sealed class LineNumber
     {
         /// <summary>
         /// Used when Linenumber is zero: index to symbol table entry for a function.

SabreTools.Models/COFF/OptionalHeader.cs

@@ -0,0 +1,88 @@
+namespace SabreTools.Models.COFF
+{
+    /// <summary>
+    /// Every image file has an optional header that provides information to the loader.
+    /// This header is optional in the sense that some files (specifically, object files)
+    /// do not have it. For image files, this header is required. An object file can have
+    /// an optional header, but generally this header has no function in an object file
+    /// except to increase its size.
+    /// 
+    /// Note that the size of the optional header is not fixed. The SizeOfOptionalHeader
+    /// field in the COFF header must be used to validate that a probe into the file for
+    /// a particular data directory does not go beyond SizeOfOptionalHeader.
+    /// 
+    /// The NumberOfRvaAndSizes field of the optional header should also be used to ensure
+    /// that no probe for a particular data directory entry goes beyond the optional header.
+    /// In addition, it is important to validate the optional header magic number for format
+    /// compatibility.
+    /// 
+    /// The optional header magic number determines whether an image is a PE32 or
+    /// PE32+ executable.
+    /// 
+    /// PE32+ images allow for a 64-bit address space while limiting the image size to
+    /// 2 gigabytes. Other PE32+ modifications are addressed in their respective sections.
+    /// 
+    /// The first eight fields of the optional header are standard fields that are defined
+    /// for every implementation of COFF. These fields contain general information that is
+    /// useful for loading and running an executable file. They are unchanged for the
+    /// PE32+ format.
+    /// </summary>
+    /// <see href="https://learn.microsoft.com/en-us/windows/win32/debug/pe-format"/>
+    public class OptionalHeader
+    {
+        /// <summary>
+        /// The unsigned integer that identifies the state of the image file. The most
+        /// common number is 0x10B, which identifies it as a normal executable file.
+        /// 0x107 identifies it as a ROM image, and 0x20B identifies it as a PE32+ executable. 
+        /// </summary>
+        public OptionalHeaderMagicNumber Magic { get; set; }
+
+        /// <summary>
+        /// The linker major version number.
+        /// </summary>
+        public byte MajorLinkerVersion { get; set; }
+
+        /// <summary>
+        /// The linker minor version number.
+        /// </summary>
+        public byte MinorLinkerVersion { get; set; }
+
+        /// <summary>
+        /// The size of the code (text) section, or the sum of all code sections if there
+        /// are multiple sections.
+        /// </summary>
+        public uint SizeOfCode { get; set; }
+
+        /// <summary>
+        /// The size of the initialized data section, or the sum of all such sections if
+        /// there are multiple data sections.
+        /// </summary>
+        public uint SizeOfInitializedData { get; set; }
+
+        /// <summary>
+        /// The size of the uninitialized data section (BSS), or the sum of all such sections
+        /// if there are multiple BSS sections.
+        /// </summary>
+        public uint SizeOfUninitializedData { get; set; }
+
+        /// <summary>
+        /// The address of the entry point relative to the image base when the executable file
+        /// is loaded into memory. For program images, this is the starting address. For
+        /// device drivers, this is the address of the initialization function. An entry point
+        /// is optional for DLLs. When no entry point is present, this field must be zero.
+        /// </summary>
+        public uint AddressOfEntryPoint { get; set; }
+
+        /// <summary>
+        /// The address that is relative to the image base of the beginning-of-code section when
+        /// it is loaded into memory. 
+        /// </summary>
+        public uint BaseOfCode { get; set; }
+
+        /// <summary>
+        /// The address that is relative to the image base of the beginning-of-data section when
+        /// it is loaded into memory. 
+        /// </summary>
+        public uint BaseOfData { get; set; }
+    }
+}

SabreTools.Models/COFF/Relocation.cs

@@ -1,6 +1,6 @@
 using System.Runtime.InteropServices;
 
-namespace SabreTools.Models.PortableExecutable
+namespace SabreTools.Models.COFF
 {
     /// <summary>
     /// Object files contain COFF relocations, which specify how the section data
@@ -18,7 +18,7 @@ namespace SabreTools.Models.PortableExecutable
     /// </summary>
     /// <see href="https://learn.microsoft.com/en-us/windows/win32/debug/pe-format"/>
     [StructLayout(LayoutKind.Sequential)]
-    public sealed class COFFRelocation
+    public sealed class Relocation
     {
         /// <summary>
         /// The address of the item to which relocation is applied. This is the

SabreTools.Models/COFF/SectionHeader.cs

@@ -1,4 +1,4 @@
-namespace SabreTools.Models.PortableExecutable
+namespace SabreTools.Models.COFF
 {
     /// <summary>
     /// Each row of the section table is, in effect, a section header. This table
@@ -29,7 +29,8 @@
         /// characters. Long names in object files are truncated if they are emitted
         /// to an executable file. 
         /// </summary>
-        public byte[]? Name { get; set; } = new byte[8];
+        /// <remarks>8 bytes</remarks>
+        public byte[]? Name { get; set; }
 
         /// <summary>
         /// The total size of the section when loaded into memory. If this value is
@@ -100,11 +101,11 @@
         /// <summary>
         /// COFF Relocations (Object Only)
         /// </summary>
-        public COFFRelocation?[]? COFFRelocations { get; set; }
+        public Relocation[]? COFFRelocations { get; set; }
 
         /// <summary>
         /// COFF Line Numbers (Deprecated)
         /// </summary>
-        public COFFLineNumber?[]? COFFLineNumbers { get; set; }
+        public LineNumber[]? COFFLineNumbers { get; set; }
     }
 }

SabreTools.Models/COFF/StringTable.cs

@@ -1,4 +1,4 @@
-namespace SabreTools.Models.PortableExecutable
+namespace SabreTools.Models.COFF
 {
     /// <summary>
     /// Immediately following the COFF symbol table is the COFF string table. The
@@ -6,7 +6,7 @@
     /// COFF header and adding the number of symbols multiplied by the size of a symbol.
     /// </summary>
     /// <see href="https://learn.microsoft.com/en-us/windows/win32/debug/pe-format"/>
-    public sealed class COFFStringTable
+    public sealed class StringTable
     {
         /// <summary>
         /// At the beginning of the COFF string table are 4 bytes that contain the

SabreTools.Models/COFF/SymbolTableEntries/BaseEntry.cs

@@ -0,0 +1,32 @@
+namespace SabreTools.Models.COFF.SymbolTableEntries
+{
+    /// <summary>
+    /// The symbol table in this section is inherited from the traditional
+    /// COFF format. It is distinct from Microsoft Visual C++ debug information.
+    /// A file can contain both a COFF symbol table and Visual C++ debug
+    /// information, and the two are kept separate. Some Microsoft tools use
+    /// the symbol table for limited but important purposes, such as
+    /// communicating COMDAT information to the linker. Section names and file
+    /// names, as well as code and data symbols, are listed in the symbol table.
+    /// 
+    /// The location of the symbol table is indicated in the COFF header.
+    /// 
+    /// The symbol table is an array of records, each 18 bytes long. Each record
+    /// is either a standard or auxiliary symbol-table record. A standard record
+    /// defines a symbol or name.
+    /// 
+    /// Auxiliary symbol table records always follow, and apply to, some standard
+    /// symbol table record. An auxiliary record can have any format that the tools
+    /// can recognize, but 18 bytes must be allocated for them so that symbol table
+    /// is maintained as an array of regular size. Currently, Microsoft tools
+    /// recognize auxiliary formats for the following kinds of records: function
+    /// definitions, function begin and end symbols (.bf and .ef), weak externals,
+    /// file names, and section definitions.
+    /// 
+    /// The traditional COFF design also includes auxiliary-record formats for arrays
+    /// and structures.Microsoft tools do not use these, but instead place that
+    /// symbolic information in Visual C++ debug format in the debug sections.
+    /// </summary>
+    /// <see href="https://learn.microsoft.com/en-us/windows/win32/debug/pe-format"/>
+    public abstract class BaseEntry { }
+}

SabreTools.Models/COFF/SymbolTableEntries/CLRTokenDefinition.cs

@@ -0,0 +1,33 @@
+namespace SabreTools.Models.COFF.SymbolTableEntries
+{
+    /// <summary>
+    /// Auxiliary Format 6: CLR Token Definition (Object Only)
+    /// 
+    /// This auxiliary symbol generally follows the IMAGE_SYM_CLASS_CLR_TOKEN. It is
+    /// used to associate a token with the COFF symbol table's namespace.
+    /// </summary>
+    /// <see href="https://learn.microsoft.com/en-us/windows/win32/debug/pe-format"/>
+    public class CLRTokenDefinition : BaseEntry
+    {
+        /// <summary>
+        /// Must be IMAGE_AUX_SYMBOL_TYPE_TOKEN_DEF (1).
+        /// </summary>
+        public byte AuxType { get; set; }
+
+        /// <summary>
+        /// Reserved, must be zero.
+        /// </summary>
+        public byte Reserved1 { get; set; }
+
+        /// <summary>
+        /// The symbol index of the COFF symbol to which this CLR token definition refers.
+        /// </summary>
+        public uint SymbolTableIndex { get; set; }
+
+        /// <summary>
+        /// Reserved, must be zero.
+        /// </summary>
+        /// <remarks>12 bytes</remarks>
+        public byte[]? Reserved2 { get; set; }
+    }
+}

SabreTools.Models/COFF/SymbolTableEntries/Descriptor.cs

@@ -0,0 +1,53 @@
+namespace SabreTools.Models.COFF.SymbolTableEntries
+{
+    /// <summary>
+    /// Auxiliary Format 2: .bf and .ef Symbols
+    /// 
+    /// For each function definition in the symbol table, three items describe
+    /// the beginning, ending, and number of lines. Each of these symbols has
+    /// storage class FUNCTION (101):
+    /// 
+    /// A symbol record named .bf (begin function). The Value field is unused.
+    /// 
+    /// A symbol record named .lf (lines in function). The Value field gives the
+    /// number of lines in the function.
+    ///
+    /// A symbol record named .ef (end of function). The Value field has the same
+    /// number as the Total Size field in the function-definition symbol record.
+    ///
+    // The .bf and .ef symbol records (but not .lf records) are followed by an
+    // auxiliary record with the following format:
+    /// </summary>
+    /// <see href="https://learn.microsoft.com/en-us/windows/win32/debug/pe-format"/>
+    public class Descriptor : BaseEntry
+    {
+        /// <summary>
+        /// Unused
+        /// </summary>
+        public uint Unused1 { get; set; }
+
+        /// <summary>
+        /// The actual ordinal line number (1, 2, 3, and so on) within the source file,
+        /// corresponding to the .bf or .ef record.
+        /// </summary>
+        public ushort Linenumber { get; set; }
+
+        /// <summary>
+        /// Unused
+        /// </summary>
+        /// <remarks>6 bytes</remarks>
+        public byte[]? Unused2 { get; set; }
+
+        /// <summary>
+        /// The symbol-table index of the next .bf symbol record. If the function is the
+        /// last in the symbol table, this field is set to zero. It is not used for
+        /// .ef records.
+        /// </summary>
+        public uint PointerToNextFunction { get; set; }
+
+        /// <summary>
+        /// Unused
+        /// </summary>
+        public ushort Unused3 { get; set; }
+    }
+}

SabreTools.Models/COFF/SymbolTableEntries/FileRecord.cs

@@ -0,0 +1,20 @@
+namespace SabreTools.Models.COFF.SymbolTableEntries
+{
+    /// <summary>
+    /// Auxiliary Format 4: Files
+    /// 
+    /// This format follows a symbol-table record with storage class FILE (103).
+    /// The symbol name itself should be .file, and the auxiliary record that
+    /// follows it gives the name of a source-code file.
+    /// </summary>
+    /// <see href="https://learn.microsoft.com/en-us/windows/win32/debug/pe-format"/>
+    public class FileRecord : BaseEntry
+    {
+        /// <summary>
+        /// An ANSI string that gives the name of the source file. This is padded
+        /// with nulls if it is less than the maximum length.
+        /// </summary>
+        /// <remarks>18 bytes</remarks>
+        public byte[]? FileName { get; set; }
+    }
+}

SabreTools.Models/COFF/SymbolTableEntries/FunctionDefinition.cs

@@ -0,0 +1,47 @@
+namespace SabreTools.Models.COFF.SymbolTableEntries
+{
+    /// <summary>
+    /// Auxiliary Format 1: Function Definitions
+    /// 
+    /// A symbol table record marks the beginning of a function definition if it
+    /// has all of the following: a storage class of EXTERNAL (2), a Type value
+    /// that indicates it is a function (0x20), and a section number that is
+    /// greater than zero. Note that a symbol table record that has a section
+    /// number of UNDEFINED (0) does not define the function and does not have
+    /// an auxiliary record. Function-definition symbol records are followed by
+    /// an auxiliary record in the format described below:
+    /// </summary>
+    /// <see href="https://learn.microsoft.com/en-us/windows/win32/debug/pe-format"/>
+    public class FunctionDefinition : BaseEntry
+    {
+        /// <summary>
+        /// The symbol-table index of the corresponding .bf (begin function)
+        /// symbol record.
+        /// </summary>
+        public uint TagIndex { get; set; }
+
+        /// <summary>
+        /// The size of the executable code for the function itself. If the function
+        /// is in its own section, the SizeOfRawData in the section header is greater
+        /// or equal to this field, depending on alignment considerations.
+        /// </summary>
+        public uint TotalSize { get; set; }
+
+        /// <summary>
+        /// The file offset of the first COFF line-number entry for the function, or
+        /// zero if none exists.
+        /// </summary>
+        public uint PointerToLinenumber { get; set; }
+
+        /// <summary>
+        /// The symbol-table index of the record for the next function. If the function
+        /// is the last in the symbol table, this field is set to zero.
+        /// </summary>
+        public uint PointerToNextFunction { get; set; }
+
+        /// <summary>
+        /// Unused
+        /// </summary>
+        public ushort Unused { get; set; }
+    }
+}

SabreTools.Models/COFF/SymbolTableEntries/SectionDefinition.cs

@@ -0,0 +1,54 @@
+namespace SabreTools.Models.COFF.SymbolTableEntries
+{
+    /// <summary>
+    /// Auxiliary Format 5: Section Definitions
+    /// 
+    /// This format follows a symbol-table record that defines a section. Such a
+    /// record has a symbol name that is the name of a section (such as .text or
+    /// .drectve) and has storage class STATIC (3). The auxiliary record provides
+    /// information about the section to which it refers. Thus, it duplicates some
+    /// of the information in the section header.
+    /// </summary>
+    /// <see href="https://learn.microsoft.com/en-us/windows/win32/debug/pe-format"/>
+    public class SectionDefinition : BaseEntry
+    {
+        /// <summary>
+        /// The size of section data; the same as SizeOfRawData in the section header.
+        /// </summary>
+        public uint Length { get; set; }
+
+        /// <summary>
+        /// The number of relocation entries for the section.
+        /// </summary>
+        public ushort NumberOfRelocations { get; set; }
+
+        /// <summary>
+        /// The number of line-number entries for the section.
+        /// </summary>
+        public ushort NumberOfLinenumbers { get; set; }
+
+        /// <summary>
+        /// The checksum for communal data. It is applicable if the IMAGE_SCN_LNK_COMDAT
+        /// flag is set in the section header.
+        /// </summary>
+        public uint CheckSum { get; set; }
+
+        /// <summary>
+        /// One-based index into the section table for the associated section. This is
+        /// used when the COMDAT selection setting is 5.
+        /// </summary>
+        public ushort Number { get; set; }
+
+        /// <summary>
+        /// The COMDAT selection number. This is applicable if the section is a
+        /// COMDAT section.
+        /// </summary>
+        public byte Selection { get; set; }
+
+        /// <summary>
+        /// Unused
+        /// </summary>
+        /// <remarks>3 bytes</remarks>
+        public byte[]? Unused { get; set; }
+    }
+}

SabreTools.Models/COFF/SymbolTableEntries/StandardRecord.cs

@@ -0,0 +1,58 @@
+namespace SabreTools.Models.COFF.SymbolTableEntries
+{
+    /// <summary>
+    /// A standard record defines a symbol or name.
+    /// </summary>
+    /// <see href="https://learn.microsoft.com/en-us/windows/win32/debug/pe-format"/>
+    public class StandardRecord : BaseEntry
+    {
+        #region Symbol Name
+
+        /// <summary>
+        /// An array of 8 bytes. This array is padded with nulls on the right if
+        /// the name is less than 8 bytes long.
+        /// </summary>
+        public byte[]? ShortName { get; set; } = new byte[8];
+
+        /// <summary>
+        /// A field that is set to all zeros if the name is longer than 8 bytes.
+        /// </summary>
+        public uint Zeroes { get; set; }
+
+        /// <summary>
+        /// An offset into the string table.
+        /// </summary>
+        public uint Offset { get; set; }
+
+        #endregion
+
+        /// <summary>
+        /// The value that is associated with the symbol. The interpretation of this
+        /// field depends on SectionNumber and StorageClass. A typical meaning is the
+        /// relocatable address.
+        /// </summary>
+        public uint Value { get; set; }
+
+        /// <summary>
+        /// The signed integer that identifies the section, using a one-based index
+        /// into the section table. Some values have special meaning.
+        /// </summary>
+        public SectionNumber SectionNumber { get; set; }
+
+        /// <summary>
+        /// A number that represents type. Microsoft tools set this field to 0x20
+        /// (function) or 0x0 (not a function).
+        /// </summary>
+        public SymbolType SymbolType { get; set; }
+
+        /// <summary>
+        /// An enumerated value that represents storage class.
+        /// </summary>
+        public StorageClass StorageClass { get; set; }
+
+        /// <summary>
+        /// The number of auxiliary symbol table entries that follow this record.
+        /// </summary>
+        public byte NumberOfAuxSymbols { get; set; }
+    }
+}

SabreTools.Models/COFF/SymbolTableEntries/WeakExternal.cs

@@ -0,0 +1,45 @@
+namespace SabreTools.Models.COFF.SymbolTableEntries
+{
+    /// <summary>
+    /// Auxiliary Format 3: Weak Externals
+    /// 
+    /// "Weak externals" are a mechanism for object files that allows flexibility at
+    /// link time. A module can contain an unresolved external symbol (sym1), but it
+    /// can also include an auxiliary record that indicates that if sym1 is not
+    /// present at link time, another external symbol (sym2) is used to resolve
+    /// references instead.
+    /// 
+    /// If a definition of sym1 is linked, then an external reference to the symbol
+    /// is resolved normally. If a definition of sym1 is not linked, then all references
+    /// to the weak external for sym1 refer to sym2 instead. The external symbol, sym2,
+    /// must always be linked; typically, it is defined in the module that contains
+    /// the weak reference to sym1.
+    ///
+    /// Weak externals are represented by a symbol table record with EXTERNAL storage
+    /// class, UNDEF section number, and a value of zero. The weak-external symbol
+    /// record is followed by an auxiliary record with the following format:
+    /// </summary>
+    /// <see href="https://learn.microsoft.com/en-us/windows/win32/debug/pe-format"/>
+    public class WeakExternal : BaseEntry
+    {
+        /// <summary>
+        /// The symbol-table index of sym2, the symbol to be linked if sym1 is not found. 
+        /// </summary>
+        public uint TagIndex { get; set; }
+
+        /// <summary>
+        /// A value of IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY indicates that no library search
+        /// for sym1 should be performed.
+        /// A value of IMAGE_WEAK_EXTERN_SEARCH_LIBRARY indicates that a library search for
+        /// sym1 should be performed.
+        /// A value of IMAGE_WEAK_EXTERN_SEARCH_ALIAS indicates that sym1 is an alias for sym2.
+        /// </summary>
+        public uint Characteristics { get; set; }
+
+        /// <summary>
+        /// Unused
+        /// </summary>
+        /// <remarks>10 bytes</remarks>
+        public byte[]? Unused { get; set; }
+    }
+}

SabreTools.Models/ClrMamePro/MetadataFile.cs

@@ -6,6 +6,6 @@ namespace SabreTools.Models.ClrMamePro
         public ClrMamePro? ClrMamePro { get; set; }
 
         /// <remarks>game, machine, resource, set</remarks>
-        public GameBase?[]? Game { get; set; }
+        public GameBase[]? Game { get; set; }
     }
 }

SabreTools.Models/ClrMamePro/Rom.cs

@@ -34,6 +34,18 @@ namespace SabreTools.Models.ClrMamePro
 
         #region Hash Extensions
 
+        /// <remarks>md2; Appears after CRC</remarks>
+        public string? MD2 { get; set; }
+
+        /// <remarks>md4; Appears after MD2</remarks>
+        public string? MD4 { get; set; }
+
+        /// <remarks>ripemd128; Appears after MD5</remarks>
+        public string? RIPEMD128 { get; set; }
+
+        /// <remarks>ripemd160; Appears after RIPEMD128</remarks>
+        public string? RIPEMD160 { get; set; }
+
         /// <remarks>sha256; Also in No-Intro spec; Appears after SHA1</remarks>
         public string? SHA256 { get; set; }
 

SabreTools.Models/Compression/Deflate/BlockHeader.cs

@@ -1,18 +0,0 @@
-namespace SabreTools.Models.Compression.Deflate
-{
-    /// <see href="https://www.rfc-editor.org/rfc/rfc1951"/>
-    public class BlockHeader
-    {
-        /// <summary>
-        /// Set if and only if this is the last block of the data set.
-        /// </summary>
-        /// <remarks>Bit 0</remarks>
-        public bool BFINAL { get; set; }
-
-        /// <summary>
-        /// Specifies how the data are compressed
-        /// </summary>
-        /// <remarks>Bits 1-2</remarks>
-        public CompressionType BTYPE { get; set; }
-    }
-}

SabreTools.Models/Compression/Deflate/CompressedDataHeader.cs

@@ -1,20 +0,0 @@
-namespace SabreTools.Models.Compression.Deflate
-{
-    /// <summary>
-    /// Compression with Huffman codes (BTYPE=01 or BTYPE=02)
-    /// </summary>
-    /// <see href="https://interoperability.blob.core.windows.net/files/MS-MCI/%5bMS-MCI%5d.pdf"/>
-    /// <see href="https://www.rfc-editor.org/rfc/rfc1951"/>
-    public abstract class CompressedDataHeader : DataHeader
-    {
-        /// <summary>
-        /// Huffman code lengths for the literal / length alphabet
-        /// </summary>
-        public virtual uint[]? LiteralLengths { get; set; }
-
-        /// <summary>
-        /// Huffman distance codes for the literal / length alphabet
-        /// </summary>
-        public virtual uint[]? DistanceCodes { get; set; }
-    }
-}

SabreTools.Models/Compression/Deflate/Constants.cs

@@ -1,136 +0,0 @@
-namespace SabreTools.Models.Compression.Deflate
-{
-    /// <see href="https://www.rfc-editor.org/rfc/rfc1951"/>
-    public static class Constants
-    {
-        /// <summary>
-        /// Bits in base literal/length lookup table
-        /// </summary>
-        public const int ZIPLBITS = 9;
-
-        /// <summary>
-        /// Bits in base distance lookup table
-        /// </summary>
-        public const int ZIPDBITS = 6;
-
-        /// <summary>
-        /// Maximum bit length of any code
-        /// </summary>
-        public const int ZIPBMAX = 16;
-
-        /// <summary>
-        /// Maximum number of codes in any set
-        /// </summary>
-        public const int ZIPN_MAX = 288;
-
-        #region Fixed Huffman Codes
-
-        /// <summary>
-        /// Fixed Huffman code lengths for the literal / length alphabet
-        /// </summary>
-        public static readonly uint[] FixedLiteralLengths =
-        [
-            8, 8, 8, 8, 8, 8, 8, 8,
-            8, 8, 8, 8, 8, 8, 8, 8,
-            8, 8, 8, 8, 8, 8, 8, 8,
-            8, 8, 8, 8, 8, 8, 8, 8,
-            8, 8, 8, 8, 8, 8, 8, 8,
-            8, 8, 8, 8, 8, 8, 8, 8,
-            8, 8, 8, 8, 8, 8, 8, 8,
-            8, 8, 8, 8, 8, 8, 8, 8,
-            8, 8, 8, 8, 8, 8, 8, 8,
-            8, 8, 8, 8, 8, 8, 8, 8,
-            8, 8, 8, 8, 8, 8, 8, 8,
-            8, 8, 8, 8, 8, 8, 8, 8,
-            8, 8, 8, 8, 8, 8, 8, 8,
-            8, 8, 8, 8, 8, 8, 8, 8,
-            8, 8, 8, 8, 8, 8, 8, 8,
-            8, 8, 8, 8, 8, 8, 8, 8,
-            8, 8, 8, 8, 8, 8, 8, 8,
-            8, 8, 8, 8, 8, 8, 8, 8,
-            9, 9, 9, 9, 9, 9, 9, 9,
-            9, 9, 9, 9, 9, 9, 9, 9,
-            9, 9, 9, 9, 9, 9, 9, 9,
-            9, 9, 9, 9, 9, 9, 9, 9,
-            9, 9, 9, 9, 9, 9, 9, 9,
-            9, 9, 9, 9, 9, 9, 9, 9,
-            9, 9, 9, 9, 9, 9, 9, 9,
-            9, 9, 9, 9, 9, 9, 9, 9,
-            9, 9, 9, 9, 9, 9, 9, 9,
-            9, 9, 9, 9, 9, 9, 9, 9,
-            9, 9, 9, 9, 9, 9, 9, 9,
-            9, 9, 9, 9, 9, 9, 9, 9,
-            9, 9, 9, 9, 9, 9, 9, 9,
-            9, 9, 9, 9, 9, 9, 9, 9,
-            7, 7, 7, 7, 7, 7, 7, 7,
-            7, 7, 7, 7, 7, 7, 7, 7,
-            7, 7, 7, 7, 7, 7, 7, 7,
-            8, 8, 8, 8, 8, 8, 8, 8,
-        ];
-
-        /// <summary>
-        /// Fixed Huffman distance codes for the literal / length alphabet
-        /// </summary>
-        public static readonly uint[] FixedDistanceCodes =
-        [
-            5, 5, 5, 5, 5, 5, 5, 5,
-            5, 5, 5, 5, 5, 5, 5, 5,
-            5, 5, 5, 5, 5, 5, 5, 5,
-            5, 5, 5, 5, 5, 5,
-        ];
-
-        #endregion
-
-        #region Literal and Length Alphabets
-
-        /// <summary>
-        /// Extra bits for distance codes
-        /// </summary>
-        public static readonly ushort[] DistanceExtraBits =
-        [
-            0, 0, 0, 0, 1, 1, 2, 2, 3, 3,
-            4, 4, 5, 5, 6, 6, 7, 7, 8, 8,
-            9, 9, 10, 10, 11, 11, 12, 12, 13, 13
-        ];
-
-        /// <summary>
-        /// Copy offsets for distance codes 0..29
-        /// </summary>
-        public static readonly ushort[] DistanceOffsets =
-        [
-            1, 2, 3, 4, 5, 7, 9, 13, 17, 25,
-            33, 49, 65, 97, 129, 193, 257, 385, 513, 769,
-            1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577
-        ];
-
-        /// <summary>
-        /// Extra bits for literal codes 257..285
-        /// </summary>
-        public static readonly ushort[] LiteralExtraBits =
-        [
-            0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
-            1, 1, 2, 2, 2, 2, 3, 3, 3, 3,
-            4, 4, 4, 4, 5, 5, 5, 5, 0,
-        ];
-
-        /// <summary>
-        /// Copy lengths for literal codes 257..285
-        /// </summary>
-        public static readonly ushort[] LiteralLengths =
-        [
-            3, 4, 5, 6, 7, 8, 9, 10, 11, 13,
-            15, 17, 19, 23, 27, 31, 35, 43, 51, 59,
-            67, 83, 99, 115, 131, 163, 195, 227, 258,
-        ];
-
-        /// <summary>
-        /// Order of the bit length code lengths
-        /// </summary>
-        public static readonly byte[] BitLengthOrder =
-        [
-            16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
-        ];
-
-        #endregion
-    }
-}

SabreTools.Models/Compression/Deflate/DataHeader.cs

@@ -1,11 +0,0 @@
-namespace SabreTools.Models.Compression.Deflate
-{
-    /// <summary>
-    /// Base class for all data headers (BTYPE=00, BTYPE=01, or BTYPE=02)
-    /// </summary>
-    /// <see href="https://www.rfc-editor.org/rfc/rfc1951"/>
-    public abstract class DataHeader
-    {
-        // No common fields between all data headers
-    }
-}

SabreTools.Models/Compression/Deflate/DynamicCompressedDataHeader.cs

@@ -1,11 +0,0 @@
-namespace SabreTools.Models.Compression.Deflate
-{
-    /// <summary>
-    /// Compression with dynamic Huffman codes (BTYPE=10)
-    /// </summary>
-    /// <see href="https://www.rfc-editor.org/rfc/rfc1951"/>
-    public class DynamicCompressedDataHeader : CompressedDataHeader
-    {
-        // Codes are provided externally
-    }
-}

SabreTools.Models/Compression/Deflate/Enums.cs

@@ -1,26 +0,0 @@
-namespace SabreTools.Models.Compression.Deflate
-{
-    /// <see href="https://www.rfc-editor.org/rfc/rfc1951"/>
-    public enum CompressionType : byte
-    {
-        /// <summary>
-        /// no compression
-        /// </summary>
-        NoCompression = 0b00,
-
-        /// <summary>
-        /// Compressed with fixed Huffman codes
-        /// </summary>
-        FixedHuffman = 0b01,
-
-        /// <summary>
-        /// Compressed with dynamic Huffman codes
-        /// </summary>
-        DynamicHuffman = 0b10,
-
-        /// <summary>
-        /// Reserved (error)
-        /// </summary>
-        Reserved = 0b11,
-    }
-}

SabreTools.Models/Compression/Deflate/FixedCompressedDataHeader.cs

@@ -1,24 +0,0 @@
-namespace SabreTools.Models.Compression.Deflate
-{
-    /// <summary>
-    /// Compression with fixed Huffman codes (BTYPE=01)
-    /// </summary>
-    /// <see href="https://interoperability.blob.core.windows.net/files/MS-MCI/%5bMS-MCI%5d.pdf"/>
-    /// <see href="https://www.rfc-editor.org/rfc/rfc1951"/>
-    public class FixedCompressedDataHeader : CompressedDataHeader
-    {
-        #region Properties
-
-        /// <summary>
-        /// Huffman code lengths for the literal / length alphabet
-        /// </summary>
-        public override uint[]? LiteralLengths => Constants.FixedLiteralLengths;
-
-        /// <summary>
-        /// Huffman distance codes for the literal / length alphabet
-        /// </summary>
-        public override uint[]? DistanceCodes => Constants.FixedDistanceCodes;
-
-        #endregion
-    }
-}

SabreTools.Models/Compression/Deflate/NonCompressedDataHeader.cs

@@ -1,21 +0,0 @@
-namespace SabreTools.Models.Compression.Deflate
-{
-    /// <summary>
-    /// Non-compressed blocks (BTYPE=00)
-    /// </summary>
-    /// <see href="https://www.rfc-editor.org/rfc/rfc1951"/>
-    public class NonCompressedBlockHeader : DataHeader
-    {
-        /// <summary>
-        /// The number of data bytes in the block
-        /// </summary>
-        /// <remarks>Bytes 0-1</remarks>
-        public ushort LEN { get; set; }
-
-        /// <summary>
-        /// The one's complement of LEN
-        /// </summary>
-        /// <remarks>Bytes 2-3</remarks>
-        public ushort NLEN { get; set; }
-    }
-}

SabreTools.Models/Compression/LZ/Constants.cs

@@ -1,23 +0,0 @@
-namespace SabreTools.Models.Compression.LZ
-{
-    public static class Constants
-    {
-        public const int GETLEN	= 2048;
-
-        public const int LZ_MAGIC_LEN = 8;
-
-        public const int LZ_HEADER_LEN = 14;
-
-        public static readonly byte[] MagicBytes = [0x53, 0x5a, 0x44, 0x44, 0x88, 0xf0, 0x27, 0x33];
-
-        public static readonly string MagicString = System.Text.Encoding.ASCII.GetString(MagicBytes);
-
-        public const ulong MagicUInt64 = 0x3327f08844445a53;
-
-        public const int LZ_TABLE_SIZE = 0x1000;
-
-        public const int MAX_LZSTATES = 16;
-
-        public const int LZ_MIN_HANDLE = 0x400;
-    }
-}

SabreTools.Models/Compression/LZ/Enums.cs

@@ -1,17 +0,0 @@
-namespace SabreTools.Models.Compression.LZ
-{
-    /// <see href="https://github.com/wine-mirror/wine/blob/master/include/lzexpand.h"/>
-    public enum LZERROR
-    {
-        LZERROR_OK = 1,
-        LZERROR_NOT_LZ = 0,
-        LZERROR_BADINHANDLE = -1,
-        LZERROR_BADOUTHANDLE = -2,
-        LZERROR_READ = -3,
-        LZERROR_WRITE = -4,
-        LZERROR_GLOBALLOC = -5,
-        LZERROR_GLOBLOCK = -6,
-        LZERROR_BADVALUE = -7,
-        LZERROR_UNKNOWNALG = -8,
-    }
-}

SabreTools.Models/Compression/LZ/FileHeader.cs

@@ -1,22 +0,0 @@
-using System.Runtime.InteropServices;
-
-namespace SabreTools.Models.Compression.LZ
-{
-    /// <summary>
-    /// Format of first 14 byte of LZ compressed file
-    /// </summary>
-    /// <see href="https://github.com/wine-mirror/wine/blob/master/dlls/kernel32/lzexpand.c"/>
-    [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Ansi)]
-    public sealed class FileHeaader
-    {
-        [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 8)]
-        public string? Magic;
-
-        public byte CompressionType;
-
-        [MarshalAs(UnmanagedType.U1)]
-        public char LastChar;
-
-        public uint RealLength;
-    }
-}

SabreTools.Models/Compression/LZ/State.cs

@@ -1,72 +0,0 @@
-using System.IO;
-
-namespace SabreTools.Models.Compression.LZ
-{
-    public sealed class State
-    {
-        /// <summary>
-        /// Internal backing stream
-        /// </summary>
-        public Stream? Source { get; set; }
-
-        /// <summary>
-        /// The last char of the filename for replacement
-        /// </summary>
-        public char LastChar { get; set; }
-
-        /// <summary>
-        /// Decompressed length of the file
-        /// </summary>
-        public uint RealLength { get; set; }
-
-        /// <summary>
-        /// Position the decompressor currently is
-        /// </summary>
-        public uint RealCurrent { get; set; }
-
-        /// <summary>
-        /// Position the user wants to read from
-        /// </summary>
-        public uint RealWanted { get; set; }
-
-        /// <summary>
-        /// The rotating LZ table
-        /// </summary>
-        public byte[]? Table { get; set; }
-
-        /// <summary>
-        /// CURrent TABle ENTry
-        /// </summary>
-        public uint CurrentTableEntry { get; set; }
-
-        /// <summary>
-        /// Length and position of current string
-        /// </summary>
-        public byte StringLength { get; set; }
-
-        /// <summary>
-        /// From stringtable
-        /// </summary>
-        public uint StringPosition { get; set; }
-
-        /// <summary>
-        /// Bitmask within blocks
-        /// </summary>
-        public ushort ByteType { get; set; }
-
-        /// <summary>
-        /// GETLEN bytes
-        /// </summary>
-        public byte[]? Window { get; set; }
-
-        /// <summary>
-        /// Current read
-        /// </summary>
-        public uint WindowCurrent { get; set; }
-
-        /// <summary>
-        /// Length last got
-        /// </summary>
-        public uint WindowLength { get; set; }
-    }
-}

SabreTools.Models/Compression/LZX/AlignedOffsetBlockData.cs

@@ -1,58 +0,0 @@
-namespace SabreTools.Models.Compression.LZX
-{
-    /// <summary>
-    /// An aligned offset block is identical to the verbatim block except for the presence of the aligned offset
-    /// tree preceding the other trees.
-    /// </summary>
-    /// <see href="https://interoperability.blob.core.windows.net/files/MS-PATCH/%5bMS-PATCH%5d.pdf"/>
-    public class AlignedOffsetBlockData : BlockData
-    {
-        /// <summary>
-        /// Aligned offset tree
-        /// </summary>
-        /// <remarks>8 elements, 3 bits each</remarks>
-        public byte[]? AlignedOffsetTree { get; set; }
-
-        /// <summary>
-        /// Pretree for first 256 elements of main tree
-        /// </summary>
-        /// <remarks>20 elements, 4 bits each</remarks>
-        public byte[]? PretreeFirst256 { get; set; }
-
-        /// <summary>
-        /// Path lengths of first 256 elements of main tree
-        /// </summary>
-        /// <remarks>Encoded using pretree</remarks>
-        public int[]? PathLengthsFirst256 { get; set; }
-
-        /// <summary>
-        /// Pretree for remainder of main tree
-        /// </summary>
-        /// <remarks>20 elements, 4 bits each</remarks>
-        public byte[]? PretreeRemainder { get; set; }
-
-        /// <summary>
-        /// Path lengths of remaining elements of main tree
-        /// </summary>
-        /// <remarks>Encoded using pretree</remarks>
-        public int[]? PathLengthsRemainder { get; set; }
-
-        /// <summary>
-        /// Pretree for length tree
-        /// </summary>
-        /// <remarks>20 elements, 4 bits each</remarks>
-        public byte[]? PretreeLengthTree { get; set; }
-
-        /// <summary>
-        /// Path lengths of elements in length tree
-        /// </summary>
-        /// <remarks>Encoded using pretree</remarks>
-        public int[]? PathLengthsLengthTree { get; set; }
-
-        /// <summary>
-        /// Token sequence (matches and literals)
-        /// </summary>
-        /// <remarks>Variable</remarks>
-        public byte[]? TokenSequence { get; set; }
-    }
-}

SabreTools.Models/Compression/LZX/Block.cs

@@ -1,24 +0,0 @@
-namespace SabreTools.Models.Compression.LZX
-{
-    /// <summary>
-    /// An LZXD block represents a sequence of compressed data that is encoded with the same set of
-    /// Huffman trees, or a sequence of uncompressed data. There can be one or more LZXD blocks in a
-    /// compressed stream, each with its own set of Huffman trees. Blocks do not have to start or end on a
-    /// chunk boundary; blocks can span multiple chunks, or a single chunk can contain multiple blocks. The
-    /// number of chunks is related to the size of the data being compressed, while the number of blocks is
-    /// related to how well the data is compressed.
-    /// </summary>
-    /// <see href="https://interoperability.blob.core.windows.net/files/MS-PATCH/%5bMS-PATCH%5d.pdf"/>
-    public class Block
-    {
-        /// <summary>
-        /// Block header
-        /// </summary>
-        public BlockHeader? Header { get; set; }
-
-        /// <summary>
-        /// Block data
-        /// </summary>
-        public BlockData? BlockData { get; set; }
-    }
-}

SabreTools.Models/Compression/LZX/BlockData.cs

@@ -1,8 +0,0 @@
-namespace SabreTools.Models.Compression.LZX
-{
-    /// <see href="https://interoperability.blob.core.windows.net/files/MS-PATCH/%5bMS-PATCH%5d.pdf"/>
-    public abstract class BlockData
-    {
-        // No common fields between all block data
-    }
-}

SabreTools.Models/Compression/LZX/BlockHeader.cs

@@ -1,33 +0,0 @@
-namespace SabreTools.Models.Compression.LZX
-{
-    /// <summary>
-    /// The Block Type field, as specified in section 2.3.1.1, indicates which type of block follows,
-    /// and the Block Size field, as specified in section 2.3.1.2, indicates the number of
-    /// uncompressed bytes represented by the block. Following the generic block
-    /// header is a type-specific header that describes the remainder of the block.
-    /// </summary>
-    /// <see href="https://interoperability.blob.core.windows.net/files/MS-PATCH/%5bMS-PATCH%5d.pdf"/>
-    public class BlockHeader
-    {
-        /// <remarks>3 bits</remarks>
-        public BlockType BlockType { get; set; }
-
-        /// <summary>
-        /// Block size is the high 8 bits of 24
-        /// </summary>
-        /// <remarks>8 bits</remarks>
-        public byte BlockSizeMSB { get; set; }
-
-        /// <summary>
-        /// Block size is the middle 8 bits of 24
-        /// </summary>
-        /// <remarks>8 bits</remarks>
-        public byte BlockSizeByte2 { get; set; }
-
-        /// <summary>
-        /// Block size is the low 8 bits of 24
-        /// </summary>
-        /// <remarks>8 bits</remarks>
-        public byte BlocksizeLSB { get; set; }
-    }
-}

SabreTools.Models/Compression/LZX/Chunk.cs

@@ -1,25 +0,0 @@
-namespace SabreTools.Models.Compression.LZX
-{
-    /// <summary>
-    /// The LZXD compressor emits chunks of compressed data. A chunk represents exactly 32 KB of
-    /// uncompressed data until the last chunk in the stream, which can represent less than 32 KB. To
-    /// ensure that an exact number of input bytes represent an exact number of output bytes for each
-    /// chunk, after each 32 KB of uncompressed data is represented in the output compressed bitstream, the
-    /// output bitstream is padded with up to 15 bits of zeros to realign the bitstream on a 16-bit boundary
-    /// (even byte boundary) for the next 32 KB of data. This results in a compressed chunk of a byte-aligned
-    /// size. The compressed chunk could be smaller than 32 KB or larger than 32 KB if the data is
-    /// incompressible when the chunk is not the last one.
-    /// </summary>
-    public class Chunk
-    {
-        /// <summary>
-        /// Chunk header
-        /// </summary>
-        public ChunkHeader? Header { get; set; }
-
-        /// <summary>
-        /// Block headers and data
-        /// </summary>
-        public Block[]? Blocks { get; set; }
-    }
-}

SabreTools.Models/Compression/LZX/ChunkHeader.cs

@@ -1,46 +0,0 @@
-namespace SabreTools.Models.Compression.LZX
-{
-    /// <summary>
-    /// The LZXD compressor emits chunks of compressed data. A chunk represents exactly 32 KB of
-    /// uncompressed data until the last chunk in the stream, which can represent less than 32 KB. To
-    /// ensure that an exact number of input bytes represent an exact number of output bytes for each
-    /// chunk, after each 32 KB of uncompressed data is represented in the output compressed bitstream, the
-    /// output bitstream is padded with up to 15 bits of zeros to realign the bitstream on a 16-bit boundary
-    /// (even byte boundary) for the next 32 KB of data. This results in a compressed chunk of a byte-aligned
-    /// size. The compressed chunk could be smaller than 32 KB or larger than 32 KB if the data is
-    /// incompressible when the chunk is not the last one.
-    /// </summary>
-    public class ChunkHeader
-    {
-        /// <summary>
-        /// The LZXD engine encodes a compressed, chunk-size prefix field preceding each compressed chunk in
-        /// the compressed byte stream. The compressed, chunk-size prefix field is a byte aligned, little-endian,
-        /// 16-bit field. The chunk prefix chain could be followed in the compressed stream without
-        /// decompressing any data. The next chunk prefix is at a location computed by the absolute byte offset
-        /// location of this chunk prefix plus 2 (for the size of the chunk-size prefix field) plus the current chunk
-        /// size.
-        /// </summary>
-        public ushort ChunkSize { get; set; }
-
-        /// <summary>
-        /// The first bit in the first chunk in the LZXD bitstream (following the 2-byte, chunk-size prefix described
-        /// in section 2.2.1) indicates the presence or absence of two 16-bit fields immediately following the
-        /// single bit. If the bit is set, E8 translation is enabled for all the following chunks in the stream using the
-        /// 32-bit value derived from the two 16-bit fields as the E8_file_size provided to the compressor when E8
-        /// translation was enabled. Note that E8_file_size is completely independent of the length of the
-        /// uncompressed data. E8 call translation is disabled after the 32,768th chunk (after 1 gigabyte (GB) of
-        /// uncompressed data).
-        /// </summary>
-        public byte E8Translation { get; set; }
-
-        /// <summary>
-        /// E8 translation size, high WORD
-        /// </summary>
-        public ushort? TranslationSizeHighWord { get; set; }
-
-        /// <summary>
-        /// E8 translation size, low WORD
-        /// </summary>
-        public ushort? TranslationSizeLowWord { get; set; }
-    }
-}

SabreTools.Models/Compression/LZX/Constants.cs

@@ -1,38 +0,0 @@
-namespace SabreTools.Models.Compression.LZX
-{
-    public static class Constants
-    {
-        /* some constants defined by the LZX specification */
-        public const int LZX_MIN_MATCH = 2;
-        public const int LZX_MAX_MATCH = 257;
-        public const int LZX_NUM_CHARS = 256;
-        public const int LZX_PRETREE_NUM_ELEMENTS = 20;
-
-        /// <summary>
-        /// aligned offset tree #elements
-        /// </summary>
-        public const int LZX_ALIGNED_NUM_ELEMENTS = 8;
-
-        /// <summary>
-        /// this one missing from spec!
-        /// </summary>
-        public const int LZX_NUM_PRIMARY_LENGTHS = 7;
-
-        /// <summary>
-        /// length tree #elements
-        /// </summary>
-        public const int LZX_NUM_SECONDARY_LENGTHS = 249;
-
-        /* LZX huffman defines: tweak tablebits as desired */
-        public const int LZX_PRETREE_MAXSYMBOLS = LZX_PRETREE_NUM_ELEMENTS;
-        public const int LZX_PRETREE_TABLEBITS = 6;
-        public const int LZX_MAINTREE_MAXSYMBOLS = LZX_NUM_CHARS + 50 * 8;
-        public const int LZX_MAINTREE_TABLEBITS = 12;
-        public const int LZX_LENGTH_MAXSYMBOLS = LZX_NUM_SECONDARY_LENGTHS + 1;
-        public const int LZX_LENGTH_TABLEBITS = 12;
-        public const int LZX_ALIGNED_MAXSYMBOLS = LZX_ALIGNED_NUM_ELEMENTS;
-        public const int LZX_ALIGNED_TABLEBITS = 7;
-
-        public const int LZX_LENTABLE_SAFETY = 64; /* we allow length table decoding overruns */
-    }
-}

SabreTools.Models/Compression/LZX/Enums.cs

@@ -1,48 +0,0 @@
-namespace SabreTools.Models.Compression.LZX
-{
-    /// <summary>
-    /// 3-bit block type
-    /// </summary>
-    public enum BlockType : byte
-    {
-        /// <summary>
-        /// Not valid
-        /// </summary>
-        INVALID_0 = 0b000,
-
-        /// <summary>
-        /// Verbatim block
-        /// </summary>
-        Verbatim = 0b001,
-
-        /// <summary>
-        /// Aligned offset block
-        /// </summary>
-        AlignedOffset = 0b010,
-
-        /// <summary>
-        /// Uncompressed block
-        /// </summary>
-        Uncompressed = 0b011,
-
-        /// <summary>
-        /// Not valid
-        /// </summary>
-        INVALID_4 = 0b100,
-
-        /// <summary>
-        /// Not valid
-        /// </summary>
-        INVALID_5 = 0b101,
-
-        /// <summary>
-        /// Not valid
-        /// </summary>
-        INVALID_6 = 0b110,
-
-        /// <summary>
-        /// Not valid
-        /// </summary>
-        INVALID_7 = 0b111,
-    }
-}

SabreTools.Models/Compression/LZX/UncompressedBlockData.cs

@@ -1,54 +0,0 @@
-namespace SabreTools.Models.Compression.LZX
-{
-    /// <summary>
-    /// Following the generic block header, an uncompressed block begins with 1 to 16 bits of zero padding
-    /// to align the bit buffer on a 16-bit boundary. At this point, the bitstream ends and a byte stream
-    /// begins. Following the zero padding, new 32-bit values for R0, R1, and R2 are output in little-endian
-    /// form, followed by the uncompressed data bytes themselves. Finally, if the uncompressed data length
-    /// is odd, one extra byte of zero padding is encoded to realign the following bitstream.
-    /// 
-    /// Then the bitstream of byte-swapped 16-bit integers resumes for the next Block Type field (if there
-    /// are subsequent blocks).
-    /// 
-    /// The decoded R0, R1, and R2 values are used as initial repeated offset values to decode the
-    /// subsequent compressed block if present.
-    /// </summary>
-    /// <see href="https://interoperability.blob.core.windows.net/files/MS-PATCH/%5bMS-PATCH%5d.pdf"/>
-    public class UncompressedBlockData : BlockData
-    {
-        /// <summary>
-        /// Padding to align following field on 16-bit boundary
-        /// </summary>
-        /// <remarks>Bits have a value of zero</remarks>
-        public ushort PaddingBits { get; set; }
-
-        /// <summary>
-        /// Least significant to most significant byte (little-endian DWORD ([MS-DTYP]))
-        /// </summary>
-        /// <remarks>Encoded directly in the byte stream, not in the bitstream of byte-swapped 16-bit words</remarks>
-        public uint R0 { get; set; }
-
-        /// <summary>
-        /// Least significant to most significant byte (little-endian DWORD)
-        /// </summary>
-        /// <remarks>Encoded directly in the byte stream, not in the bitstream of byte-swapped 16-bit words</remarks>
-        public uint R1 { get; set; }
-
-        /// <summary>
-        /// Least significant to most significant byte (little-endian DWORD)
-        /// </summary>
-        /// <remarks>Encoded directly in the byte stream, not in the bitstream of byte-swapped 16-bit words</remarks>
-        public uint R2 { get; set; }
-
-        /// <summary>
-        /// Can use the direct memcpy function, as specified in [IEEE1003.1]
-        /// </summary>
-        /// <remarks>Encoded directly in the byte stream, not in the bitstream of byte-swapped 16-bit words</remarks>
-        public byte[]? RawDataBytes { get; set; }
-
-        /// <summary>
-        /// Only if uncompressed size is odd
-        /// </summary>
-        public byte AlignmentByte { get; set; }
-    }
-}

SabreTools.Models/Compression/LZX/VerbatimBlockData.cs

@@ -1,51 +0,0 @@
-namespace SabreTools.Models.Compression.LZX
-{
-    /// <summary>
-    /// The fields of a verbatim block that follow the generic block header
-    /// </summary>
-    /// <see href="https://interoperability.blob.core.windows.net/files/MS-PATCH/%5bMS-PATCH%5d.pdf"/>
-    public class VerbatimBlockData : BlockData
-    {
-        /// <summary>
-        /// Pretree for first 256 elements of main tree
-        /// </summary>
-        /// <remarks>20 elements, 4 bits each</remarks>
-        public byte[]? PretreeFirst256 { get; set; }
-
-        /// <summary>
-        /// Path lengths of first 256 elements of main tree
-        /// </summary>
-        /// <remarks>Encoded using pretree</remarks>
-        public int[]? PathLengthsFirst256 { get; set; }
-
-        /// <summary>
-        /// Pretree for remainder of main tree
-        /// </summary>
-        /// <remarks>20 elements, 4 bits each</remarks>
-        public byte[]? PretreeRemainder { get; set; }
-
-        /// <summary>
-        /// Path lengths of remaining elements of main tree
-        /// </summary>
-        /// <remarks>Encoded using pretree</remarks>
-        public int[]? PathLengthsRemainder { get; set; }
-
-        /// <summary>
-        /// Pretree for length tree
-        /// </summary>
-        /// <remarks>20 elements, 4 bits each</remarks>
-        public byte[]? PretreeLengthTree { get; set; }
-
-        /// <summary>
-        /// Path lengths of elements in length tree
-        /// </summary>
-        /// <remarks>Encoded using pretree</remarks>
-        public int[]? PathLengthsLengthTree { get; set; }
-
-        /// <summary>
-        /// Token sequence (matches and literals)
-        /// </summary>
-        /// <remarks>Variable</remarks>
-        public byte[]? TokenSequence { get; set; }
-    }
-}

SabreTools.Models/Compression/MSZIP/Block.cs

@@ -1,33 +0,0 @@
-namespace SabreTools.Models.Compression.MSZIP
-{
-    /// <summary>
-    /// Each MSZIP block MUST consist of a 2-byte MSZIP signature and one or more RFC 1951 blocks. The
-    /// 2-byte MSZIP signature MUST consist of the bytes 0x43 and 0x4B. The MSZIP signature MUST be
-    /// the first 2 bytes in the MSZIP block. The MSZIP signature is shown in the following packet diagram.
-    /// 
-    /// Each MSZIP block is the result of a single deflate compression operation, as defined in [RFC1951].
-    /// The compressor that performs the compression operation MUST generate one or more RFC 1951
-    /// blocks, as defined in [RFC1951]. The number, deflation mode, and type of RFC 1951 blocks in each
-    /// MSZIP block is determined by the compressor, as defined in [RFC1951]. The last RFC 1951 block in
-    /// each MSZIP block MUST be marked as the "end" of the stream(1), as defined by [RFC1951]
-    /// section 3.2.3. Decoding trees MUST be discarded after each RFC 1951 block, but the history buffer
-    /// MUST be maintained.Each MSZIP block MUST represent no more than 32 KB of uncompressed data.
-    /// 
-    /// The maximum compressed size of each MSZIP block is 32 KB + 12 bytes. This enables the MSZIP
-    /// block to contain 32 KB of data split between two noncompressed RFC 1951 blocks, each of which
-    /// has a value of BTYPE = 00.
-    /// </summary>
-    /// <see href="https://interoperability.blob.core.windows.net/files/MS-MCI/%5bMS-MCI%5d.pdf"/>
-    public class Block
-    {
-        /// <summary>
-        /// Block header
-        /// </summary>
-        public BlockHeader? BlockHeader { get; set; }
-
-        /// <summary>
-        /// Compressed blocks
-        /// </summary>
-        public DeflateBlock[]? CompressedBlocks { get; set; }
-    }
-}

SabreTools.Models/Compression/MSZIP/BlockHeader.cs

@@ -1,16 +0,0 @@
-namespace SabreTools.Models.Compression.MSZIP
-{
-    /// <summary>
-    /// Each MSZIP block MUST consist of a 2-byte MSZIP signature and one or more RFC 1951 blocks. The
-    /// 2-byte MSZIP signature MUST consist of the bytes 0x43 and 0x4B. The MSZIP signature MUST be
-    /// the first 2 bytes in the MSZIP block. The MSZIP signature is shown in the following packet diagram.
-    /// </summary>
-    /// <see href="https://interoperability.blob.core.windows.net/files/MS-MCI/%5bMS-MCI%5d.pdf"/>
-    public class BlockHeader
-    {
-        /// <summary>
-        /// 'CK'
-        /// </summary>
-        public ushort Signature { get; set; }
-    }
-}

SabreTools.Models/Compression/MSZIP/Constants.cs

@@ -1,20 +0,0 @@
-namespace SabreTools.Models.Compression.MSZIP
-{
-    /// <see href="https://github.com/wine-mirror/wine/blob/master/dlls/cabinet/cabinet.h"/>
-    public static class Constants
-    {
-        /// <summary>
-        /// Window size
-        /// </summary>
-        public const ushort ZIPWSIZE = 0x8000;
-
-        /// <summary>
-        /// And'ing with Zipmask[n] masks the lower n bits
-        /// </summary>
-        public static readonly ushort[] BitMasks =
-        [
-            0x0000, 0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,
-            0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff
-        ];
-    }
-}

SabreTools.Models/Compression/MSZIP/DeflateBlock.cs

@@ -1,35 +0,0 @@
-namespace SabreTools.Models.Compression.MSZIP
-{
-    /// <summary>
-    /// Each MSZIP block is the result of a single deflate compression operation, as defined in [RFC1951].
-    /// The compressor that performs the compression operation MUST generate one or more RFC 1951
-    /// blocks, as defined in [RFC1951]. The number, deflation mode, and type of RFC 1951 blocks in each
-    /// MSZIP block is determined by the compressor, as defined in [RFC1951]. The last RFC 1951 block in
-    /// each MSZIP block MUST be marked as the "end" of the stream(1), as defined by [RFC1951]
-    /// section 3.2.3. Decoding trees MUST be discarded after each RFC 1951 block, but the history buffer
-    /// MUST be maintained.Each MSZIP block MUST represent no more than 32 KB of uncompressed data.
-    /// </summary>
-    /// <see href="https://interoperability.blob.core.windows.net/files/MS-MCI/%5bMS-MCI%5d.pdf"/>
-    public class DeflateBlock
-    {
-        /// <summary>
-        /// Deflate block (RFC-1951) header
-        /// </summary>
-        public Deflate.BlockHeader? Header { get; set; }
-
-        /// <summary>
-        /// Compression-specific data header
-        /// </summary>
-        public Deflate.DataHeader? DataHeader { get; set; }
-
-        /// <summary>
-        /// MSZIP data
-        /// </summary>
-        /// <remarks>
-        /// Depending on the implementation of these models, this property could either be
-        /// compressed or uncompressed data. Keep this in mind when using the built
-        /// versions of this model.
-        /// </remarks>
-        public byte[]? Data { get; set; }
-    }
-}

SabreTools.Models/Compression/Quantum/Constants.cs

@@ -1,50 +0,0 @@
-namespace SabreTools.Models.Compression.Quantum
-{
-    /// <see href="www.russotto.net/quantumcomp.html"/>
-    public static class Constants
-    {
-        public static readonly int[] PositionSlot =
-        [
-            0x00000, 0x00001, 0x00002, 0x00003, 0x00004, 0x00006, 0x00008, 0x0000c,
-            0x00010, 0x00018, 0x00020, 0x00030, 0x00040, 0x00060, 0x00080, 0x000c0,
-            0x00100, 0x00180, 0x00200, 0x00300, 0x00400, 0x00600, 0x00800, 0x00c00,
-            0x01000, 0x01800, 0x02000, 0x03000, 0x04000, 0x06000, 0x08000, 0x0c000,
-            0x10000, 0x18000, 0x20000, 0x30000, 0x40000, 0x60000, 0x80000, 0xc0000,
-            0x100000, 0x180000
-        ];
-
-        public static readonly int[] PositionExtraBits =
-        [
-            0,  0,  0,  0,  1,  1,  2,  2,
-            3,  3,  4,  4,  5,  5,  6,  6,
-            7,  7,  8,  8,  9,  9, 10, 10,
-            11, 11, 12, 12, 13, 13, 14, 14,
-            15, 15, 16, 16, 17, 17, 18, 18,
-            19, 19
-        ];
-
-        public static readonly int[] LengthSlot =
-        [
-            0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x08,
-            0x0a, 0x0c, 0x0e, 0x12, 0x16, 0x1a, 0x1e, 0x26,
-            0x2e, 0x36, 0x3e, 0x4e, 0x5e, 0x6e, 0x7e, 0x9e,
-            0xbe, 0xde, 0xfe
-        ];
-
-        public static readonly int[] LengthExtraBits =
-        [
-            0,  0,  0,  0,  0,  0,  1,  1,
-            1,  1,  2,  2,  2,  2,  3,  3,
-            3,  3,  4,  4,  4,  4,  5,  5,
-            5,  5,  0
-        ];
-
-        /// <summary>
-        /// Number of position slots for (tsize - 10)
-        /// </summary>
-        public static readonly int[] NumPositionSlots =
-        [
-            20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42
-        ];
-    }
-}

SabreTools.Models/Compression/Quantum/Enums.cs

@@ -1,45 +0,0 @@
-namespace SabreTools.Models.Compression.Quantum
-{
-    public enum SelectorModel
-    {
-        /// <summary>
-        /// Literal model, 64 entries, start at symbol 0
-        /// </summary>
-        SELECTOR_0 = 0,
-
-        /// <summary>
-        /// Literal model, 64 entries, start at symbol 64
-        /// </summary>
-        SELECTOR_1 = 1,
-
-        /// <summary>
-        /// Literal model, 64 entries, start at symbol 128
-        /// </summary>
-        SELECTOR_2 = 2,
-
-        /// <summary>
-        /// Literal model, 64 entries, start at symbol 192
-        /// </summary>
-        SELECTOR_3 = 3,
-
-        /// <summary>
-        /// LZ model, 3 character matches, max 24 entries, start at symbol 0
-        /// </summary>
-        SELECTOR_4 = 4,
-
-        /// <summary>
-        /// LZ model, 4 character matches, max 36 entries, start at symbol 0
-        /// </summary>
-        SELECTOR_5 = 5,
-
-        /// <summary>
-        /// LZ model, 5+ character matches, max 42 entries, start at symbol 0
-        /// </summary>
-        SELECTOR_6_POSITION = 6,
-
-        /// <summary>
-        /// LZ model, 5+ character matches, 27 entries, start at symbol 0
-        /// </summary>
-        SELECTOR_6_LENGTH = 7,
-    }
-}

SabreTools.Models/Compression/Quantum/Model.cs

@@ -1,24 +0,0 @@
-namespace SabreTools.Models.Compression.Quantum
-{
-    /// <see href="http://www.russotto.net/quantumcomp.html"/>
-    public sealed class Model
-    {
-        public int Entries { get; set; }
-
-        /// <remarks>
-        /// All the models are initialized with the symbols in symbol
-        /// order in the table, and with every symbol in the table
-        /// having a frequency of 1
-        /// </remarks>
-        public ModelSymbol?[]? Symbols { get; set; }
-
-        /// <remarks>
-        /// The initial total frequency is equal to the number of entries
-        /// in the table
-        /// </remarks>
-        public int TotalFrequency { get; set; }
-
-        /// <remarks>The initial time_to_reorder value is 4</remarks>
-        public int TimeToReorder { get; set; }
-    }
-}

SabreTools.Models/Compression/Quantum/ModelSymbol.cs

@@ -1,15 +0,0 @@
-namespace SabreTools.Models.Compression.Quantum
-{
-    /// <see href="http://www.russotto.net/quantumcomp.html"/>
-    public sealed class ModelSymbol
-    {
-        public ushort Symbol { get; set; }
-
-        /// <summary>
-        /// The cumulative frequency is the frequency of all the symbols
-        /// which are at a higher index in the table than that symbol —
-        /// thus the last entry in the table has a cumulative frequency of 0.
-        /// </summary>
-        public ushort CumulativeFrequency { get; set; }
-    }
-}

SabreTools.Models/CueSheets/CueFile.cs

@@ -25,6 +25,6 @@ namespace SabreTools.Models.CueSheets
         /// <summary>
         /// List of TRACK in FILE
         /// </summary>
-        public CueTrack?[]? Tracks { get; set; }
+        public CueTrack[]? Tracks { get; set; }
     }
 }

SabreTools.Models/CueSheets/CueSheet.cs

@@ -36,6 +36,6 @@ namespace SabreTools.Models.CueSheets
         /// <summary>
         /// List of FILE in cuesheet
         /// </summary>
-        public CueFile?[]? Files { get; set; }
+        public CueFile[]? Files { get; set; }
     }
 }