git: Added build folders to gitignore

Co-authored-by: Nik <werwolv98@gmail.com>

.gitattributes

@@ -1,2 +1,4 @@
 *.pat               linguist-language=Rust
 *.hexpat            linguist-language=Rust
+
+tests/patterns/test_data/**  binary

.github/PULL_REQUEST_TEMPLATE/pattern_template.md

@@ -5,7 +5,8 @@
 ## Checklist
 - [ ] A pattern for this format doesn't exist yet (or this PR improves the existing one)
 - [ ] The new pattern has been added to the relevant table in the Readme
+- [ ] The new pattern has a description pragma (`#pragma description My pattern Description here`)
 - [ ] The pattern was associated with all relevant MIME types (using `#pragma MIME mime-type` in the source code)
   - Make sure to never use `application/octet-stream` here as that means "Unidentifiable binary data"
 - [ ] A test file for this pattern has been added to [/tests/patterns/test_data](/tests/patterns/test_data)
-  - Try to keep this file below ~ 1 MB 
+  - Try to keep this file below ~ 1 MB

.github/workflows/dispatch.yml

@@ -8,7 +8,7 @@ on:
   repository_dispatch:
     types: [run_tests]
   workflow_dispatch:
-    inputs: 
+    inputs:
       generate_docs:
         description: "Regenerate docs"
         required: false
@@ -17,7 +17,7 @@ on:
 jobs:
   tests:
     name: 🎯 Dispatch changes
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-24.04
     env:
       DISPATCH_TOKEN: ${{ secrets.DISPATCH_TOKEN }}
     permissions:
@@ -27,13 +27,13 @@ jobs:
 
     steps:
     - name: 🧰 Checkout
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
       with:
         submodules: recursive
 
     - name: 📄 Check changed include files
       id: changed-includes
-      uses: tj-actions/changed-files@v35
+      uses: tj-actions/changed-files@v45
       with:
         files: includes/**/*.pat
 
@@ -45,3 +45,12 @@ jobs:
         repo: Documentation
         owner: WerWolv
         event_type: update_pl_docs
+
+    - name: ✉️ Update PatternLanguage Website
+      if: ${{ env.DISPATCH_TOKEN != '' }}
+      uses: mvasigh/dispatch-action@main
+      with:
+        token: ${{ secrets.DISPATCH_TOKEN }}
+        repo: PatternLanguageWeb
+        owner: WerWolv
+        event_type: rebuild_wasm

.github/workflows/tests.yml

@@ -7,11 +7,12 @@ on:
     branches: [ '*' ]
   repository_dispatch:
     types: [run_tests]
+  workflow_call:
 
 jobs:
   tests:
     name: 🧪 Unit Tests
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-24.04
     permissions:
       actions: read
       contents: read
@@ -19,8 +20,9 @@ jobs:
 
     steps:
     - name: 🧰 Checkout
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
       with:
+        repository: ${{ github.repository_owner }}/ImHex-Patterns
         submodules: recursive
 
     - name: ⬇️ Install dependencies
@@ -28,56 +30,54 @@ jobs:
         sudo apt update
         sudo apt install -y       \
             build-essential       \
-            gcc-12                \
+            ccache                \
-            g++-12                \
+            gcc-14                \
+            g++-14                \
             lld                   \
             ${PKGCONF:-}          \
             cmake                 \
-            make                  \
+            ninja-build           \
             python3               \
             python3-pip           \
             libmagic-dev          \
             lcov
-        
+
         sudo pip install jsonschema
 
+    - name: 📜 Setup ccache
+      uses: hendrikmuhs/ccache-action@v1
+      with:
+        key: ${{ runner.os }}-ccache-${{ github.run_id }}
+        restore-keys: ${{ runner.os }}-ccache
+        max-size: 1G
+
     - name: 🛠️ Build
       run: |
-        cd tests
         mkdir -p build
         cd build
-        CC=gcc-12 CXX=g++-12 cmake                        \
+        CC=gcc-14 CXX=g++-14 cmake                        \
+          -DCMAKE_C_COMPILER_LAUNCHER=ccache              \
+          -DCMAKE_CXX_COMPILER_LAUNCHER=ccache            \
           -DCMAKE_C_FLAGS="-fuse-ld=lld --coverage"       \
           -DCMAKE_CXX_FLAGS="-fuse-ld=lld --coverage"     \
+          -DIMHEX_PATTERNS_ENABLE_UNIT_TESTS=ON           \
           -DLIBPL_ENABLE_TESTS=OFF                        \
           -DLIBPL_ENABLE_CLI=OFF                          \
+          -G Ninja                                        \
           ..
-        make -j4
+        ninja unit_tests
 
     - name: 🧪 Perform Unit Tests
       run: |
-        cd tests/build
+        cd build
-        ctest --output-on-failure
+        ctest --output-on-failure -j 4
-
-    #- name: ⚗️ Generate Coverage Report
-    #  run: |
-    #    cd tests/build
-    #    lcov -d ./_deps/pattern_language-build/lib --gcov-tool /usr/bin/gcov-12 -c -o coverage.info
-
-    #- name: ⬆️ Upload Coverage Report
-    #  uses: coverallsapp/github-action@master
-    #  env:
-    #    NODE_OPTIONS: --max-old-space-size=8000 
-    #  with:
-    #    github-token: ${{ secrets.GITHUB_TOKEN }}
-    #    path-to-lcov: tests/build/coverage.info
 
     - name: 📎 Validate JSON Files
       run: |
         cd constants
         for file in ./[!_schema.json]*; do jsonschema -i $file _schema.json; done
         cd ..
-        
+
         cd tips
         for file in ./[!_schema.json]*; do jsonschema -i $file _schema.json; done
         cd ..

.gitignore

@@ -1,5 +1,13 @@
 
-tests/cmake-build-debug/
+tests/cmake*/
+tests/build*/
+build/
+cmake-build-*/
 
+.vscode/
+.devcontainer/
+.cache/
 .idea/
-.DS_Store
+.DS_Store
+
+compile_commands.json

.gitmodules

@@ -1,4 +1,10 @@
 [submodule "rules"]
 	path = yara/official_rules
 	url = https://github.com/Yara-Rules/rules
-	branch = master
+	branch = master
+[submodule "patterns/ffx"]
+	path = patterns/ffx
+	url = https://gitlab.com/EvelynTSMG/imhex-ffx-pats.git
+[submodule "patterns/bastion"]
+	path = patterns/bastion
+	url = https://gitlab.com/EvelynTSMG/imhex-bastion-pats.git

CMakeLists.txt

@@ -0,0 +1,30 @@
+cmake_minimum_required(VERSION 3.16)
+
+project(ImHex-Patterns)
+
+option(IMHEX_PATTERNS_ENABLE_UNIT_TESTS "Enable building unit tests for ImHex-Patterns"          OFF)
+
+# if enabled, add a unit_test custom target for all the unit tests to be registered against
+if(IMHEX_PATTERNS_ENABLE_UNIT_TESTS)
+    if(NOT TARGET unit_tests)
+        enable_testing()
+        add_custom_target(unit_tests)
+    endif()
+endif()
+
+# If this has been manually cloned into another project, libpl may already have been set up
+if(NOT TARGET libpl)
+    include(FetchContent)
+
+    FetchContent_Declare(
+        pattern_language
+        GIT_REPOSITORY      https://github.com/WerWolv/PatternLanguage
+        GIT_TAG             master
+    )
+
+    FetchContent_MakeAvailable(pattern_language)
+endif()
+
+if(IMHEX_PATTERNS_ENABLE_UNIT_TESTS)
+    add_subdirectory(tests)
+endif()

CONTRIBUTING.md

@@ -8,5 +8,5 @@ Thanks a lot for any additions or improvements :)
 ## Adding new Patterns
 
 When adding new patterns, if possible, please also add a test file named `<pattern_name>.hexpat.<extension>` to the `/tests/patterns/test_data` directory. This allows our Unit Tests to be run against your code so we can make sure it stays up-to-date and doesn't break when changes are made to the PatternLanguage.
-Please try to keep these files as small as possible (~100kiB at most) so cloning stays fast. 
+Please try to keep these files as small as possible (~100kiB at most) so cloning stays fast.
 Please also make sure to not submit any test files that are under copyright such as game files, ROMs or files extracted from other programs. We don't want a DMCA takedown on this repo.

README.md

@@ -1,6 +1,7 @@
 # ImHex Database
 
 This repository serves as a database for files to use with the [ImHex Hex Editor](https://github.com/WerWolv/ImHex). It currently contains
+
 - [Patterns](/patterns) - Binary Format definitions for the Pattern Language
 - [Pattern Libraries](/includes) - Libraries that make using the Pattern Language easier
 - [Magic Files](/magic) - Custom magic file definitions for the use with libmagic
@@ -22,82 +23,191 @@ Everything will immediately show up in ImHex's Content Store and gets bundled wi
 
 | Name | MIME | Path | Description |
 |------|------|------|-------------|
-| 7Z | | [`patterns/7z.hexpat`](patterns/7z.hexpat) | 7z File Format | 
+| 3DS | | [`patterns/3ds.hexpat`](patterns/3ds.hexpat) | Autodesk 3DS Max Model file |
-| AFE2 | | [`patterns/afe2.hexpat`](patterns/afe2.hexpat) | Nintendo Switch Atmosphère CFW Fatal Error log | 
+| 7Z | | [`patterns/7z.hexpat`](patterns/7z.hexpat) | 7z File Format |
-| AR | `application/x-archive` | [`patterns/ar.hexpat`](patterns/ar.hexpat) | Static library archive files | 
+| ADTFDAT | | [`patterns/adtfdat.hexpat`](patterns/adtfdat.hexpat) | [ADTFDAT files](https://digitalwerk.gitlab.io/solutions/adtf_content/adtf_base/adtf_file_library) |
-| ARM VTOR | | [`patterns/arm_cm_vtor.hexpat`](patterns/arm_cm_vtor.hexpat) | ARM Cortex M Vector Table Layout | 
+| ADTS | `audio/x-hx-aac-adts` | [`patterns/adts.hexpat`](patterns/adts.hexpat) | ADTS/AAC audio files |
-| Bencode | `application/x-bittorrent` | [`patterns/bencode.hexpat`](patterns/bencode.hexpat) | Bencode encoding, used by Torrent files | 
+| AFE2 | | [`patterns/afe2.hexpat`](patterns/afe2.hexpat) | Nintendo Switch Atmosphère CFW Fatal Error log |
+| ANI | `application/x-navi-animation` | [`patterns/ani.hexpat`](patterns/ani.hexpat) | Windows Animated Cursor file |
+| AppleSingle | `application/applefile` | [`patterns/apple_single_double.hexpat`](patterns/apple_single_double.hexpat) | AppleSingle Dual Fork file |
+| AppleDouble | `multipart/appledouble` | [`patterns/apple_single_double.hexpat`](patterns/apple_single_double.hexpat) | AppleDouble Resource Fork/Finder Metadata file |
+| AR | `application/x-archive` | [`patterns/ar.hexpat`](patterns/ar.hexpat) | Static library archive files |
+| ARC | | [`patterns/arc.hexpat`](patterns/arc.hexpat) | Minecraft Legacy Console Edition ARC files |
+| ARIA2 | | [`patterns/aria2.hexpat`](patterns/aria2.hexpat) | ARIA2 Download Manager Control files |
+| ARM VTOR | | [`patterns/arm_cm_vtor.hexpat`](patterns/arm_cm_vtor.hexpat) | ARM Cortex M Vector Table Layout |
+| Bastion | | [`patterns/bastion/*`](https://gitlab.com/EvelynTSMG/imhex-bastion-pats) | Various [Bastion](https://en.wikipedia.org/wiki/Bastion_(video_game)) files |
+| BeyondCompare BCSS | | [`patterns/bcss.hexpat`](patterns/bcss.hexpat) | BeyondCompare Snapshot (BCSS) file |
+| Bencode | `application/x-bittorrent` | [`patterns/bencode.hexpat`](patterns/bencode.hexpat) | Bencode encoding, used by Torrent files |
+| Prusa BGCODE | | [`patterns/bgcode.hexpat`](patterns/bgcode.hexpat) | PrusaSlicer Binary G-Code files |
+| BLEND  | | [`patterns/blend.hexpat`](patterns/blend.hexpat) | Blender Project file |
 | BMP  | `image/bmp` | [`patterns/bmp.hexpat`](patterns/bmp.hexpat) | OS2/Windows Bitmap files |
-| BSON | `application/bson` | [`patterns/bson.hexpat`](patterns/bson.hexpat) | BSON (Binary JSON) format | 
+| BIN  | | [`patterns/selinux.hexpat`](patterns/selinux.pat) | SE Linux modules |
+| BINKA  | | [`patterns/binka.hexpat`](patterns/binka.pat) | RAD Game Tools Bink Audio (BINKA) files |
+| BSON | `application/bson` | [`patterns/bson.hexpat`](patterns/bson.hexpat) | BSON (Binary JSON) format |
+| bplist | `application/x-bplist` | [`patterns/bplist.hexpat`](patterns/bplist.hexpat) | Apple's binary property list format (bplist) |
 | BSP | | [`patterns/bsp_goldsrc.hexpat`](patterns/bsp_goldsrc.hexpat) | GoldSrc engine maps format (used in Half-Life 1) |
+| BZIP3 | | [`patterns/bzip3.hexpat`](patterns/bzip3.hexpat) | Parses BZip3 compression (file format) by Kamila Szewczyk |
+| CAB | | [`patterns/cab.hexpat`](patterns/cab.hexpat) | Microsoft Cabinet (CAB) Files |
 | CCHVA | | [`patterns/cchva.hexpat`](patterns/cchva.hexpat) | Command and Conquer Voxel Animation |
 | CCVXL | | [`patterns/ccvxl.hexpat`](patterns/ccvxl.hexpat) | Command and Conquer Voxel Model |
 | CCPAL | | [`patterns/ccpal.hexpat`](patterns/ccpal.hexpat) | Command and Conquer Voxel Palette |
 | CDA | | [`patterns/cda.hexpat`](patterns/cda.hexpat) | Compact Disc Audio track |
-| CHM | | [`patterns/chm.hexpat`](patterns/chm.hexpat) | Windows HtmlHelp Data (ITSF / CHM) |
+| CHD | | [`patterns/chd.hexpat`](patterns/chd.hexpat) | MAME Compressed Hunks of Data file |
+| CHM | `application/vnd.ms-htmlhelp` | [`patterns/chm.hexpat`](patterns/chm.hexpat) | Windows HtmlHelp Data (ITSF / CHM) |
 | COFF | `application/x-coff` | [`patterns/coff.hexpat`](patterns/coff.hexpat) | Common Object File Format (COFF) executable |
 | CPIO | `application/x-cpio` | [`patterns/cpio.hexpat`](patterns/cpio.hexpat) | Old Binary CPIO Format |
-| CrashLvl | | [`patterns/Crashlvl.hexpat`](patterns/Crashlvl.hexpat) | Crash Bandicoot - Back in Time (fan game) User created flashback tapes level format |
+| CrashLvl | | [`patterns/Crashlvl.hexpat`](patterns/Crashlvl.hexpat) | Crash Bandicoot - Back in Time (fan game) User created level format |
+| CREDHIST | | [`patterns/credhist.hexpat`](patterns/credhist.hexpat) | CREDHIST Format |
 | DDS | `image/vnd-ms.dds` | [`patterns/dds.hexpat`](patterns/dds.hexpat) | DirectDraw Surface |
 | DEX | | [`patterns/dex.hexpat`](patterns/dex.hexpat) | Dalvik EXecutable Format |
+| DICOM | `application/dicom` | [`patterns/dicom.hexpat`](patterns/dicom.hexpat) | DICOM image format |
 | DMG | | [`patterns/dmg.hexpat`](patterns/dmg.hexpat) | Apple Disk Image Trailer (DMG) |
-| DS_Store | `application/octet-stream` | [`patterns/dsstore.hexpat`](patterns/dsstore.hexpat) | .DS_Store file format |
+| DMP | | [`patterns/dmp64.hexpat`](patterns/dmp64.hexpat) | Windows Kernel Dump(DMP64) |
+| DOTNET_BinaryFormatter | | [`patterns/dotnet_binaryformatter.hexpat`](patterns/dotnet_binaryformatter.hexpat) | .NET BinaryFormatter |
+| DPAPI_Blob | | [`patterns/dpapblob.hexpat`](patterns/dpapiblob.hexpat) | Data protection API Blob File Format |
+| DPAPI_MasterKey | | [`patterns/dpapimasterkey.hexpat`](patterns/dpapimasterkey.hexpat) | Data protection API MasterKey |
+| DS_Store | | [`patterns/dsstore.hexpat`](patterns/dsstore.hexpat) | .DS_Store file format |
 | DTA | | [`patterns/max_v104.hexpat`](patterns/max_v104.hexpat) | Mechanized Assault and Exploration v1.04 (strategy game) save file format |
+| DTED | | [`patterns/dted.hexpat`](patterns/dted.hexpat) | Digital Terrain Elevation Data (DTED) |
 | ELF  | `application/x-executable` | [`patterns/elf.hexpat`](patterns/elf.hexpat) | ELF header in elf binaries |
-| EVTX | | [`patterns/evtx.hexpat`](patterns/evtx.hexpat) | MS Windows Vista Event Log |
+| EVTX | `application/x-ms-evtx` | [`patterns/evtx.hexpat`](patterns/evtx.hexpat) | MS Windows Vista Event Log |
+| EXFAT | | [`patterns/fs/exfat.hexpat`](patterns/fs/exfat.hexpat) | Extensible File Allocation Table (exFAT) |
+| EXT4 | | [`patterns/fs/ext4.hexpat`](patterns/fs/ext4.hexpat) | Ext4 File System |
+| FAS | | [`patterns/fas_oskasoftware.hexpat`](patterns/fas_oskasoftware.hexpat) [`patterns/fas_oskasoftware_old.hexpat`](patterns/fas_oskasoftware_old.hexpat) (Old versions of Oska DeskMate) | Oska Software DeskMates FAS (Frames and Sequences) file |
+| FAT32 | | [`patterns/fs/fat32.hexpat`](patterns/fs/fat32.hexpat) | FAT32 File System |
+| FBX | | [`patterns/fbx.hexpat`](patterns/fbx.hexpat) | Kaydara FBX Binary |
 | FDT | | [`patterns/fdt.hexpat`](patterns/fdt.hexpat) | Flat Linux Device Tree blob |
-| File System | | [`patterns/fs.hexpat`](patterns/fs.hexpat) | Drive File System | 
+| FFX | | [`patterns/ffx/*`](https://gitlab.com/EvelynTSMG/imhex-ffx-pats) | Various Final Fantasy X files |
-| FLAC | `audio/flac` | [`patterns/flac.hexpat`](patterns/flac.hexpat) | Free Lossless Audio Codec, FLAC Audio Format | 
+| File System | `application/x-ima` | [`patterns/fs/pattern.hexpat`](patterns/fs/pattern.hexpat) | Drive File System |
-| GB | `application/x-gameboy-rom` | [`patterns/gb.hexpat`](patterns/gb.hexpat) | Gameboy ROM |
+| FLAC | `audio/flac` | [`patterns/flac.hexpat`](patterns/flac.hexpat) | Free Lossless Audio Codec, FLAC Audio Format |
+| FLC/FLIC | | [`patterns/flc.hexpat`](patterns/flc.hexpat) | FLC/FLIC animation file |
+| FLV | | [`patterns/flv.hexpat`](patterns/flv.hexpat) | FLv animation file |
+| Flipper Zero Settings | | [`patterns/flipper_settings.hexpat`](patterns/flipper_settings.hexpat) | Flipper Zero Settings Files |
+| GB | `application/x-gameboy-rom` | [`patterns/gb.hexpat`](patterns/gb.hexpat) | Game Boy ROM |
+| GBA | `application/x-gameboy-advance-rom` | [`patterns/gba.hexpat`](patterns/gba.hexpat) | Game Boy Advance ROM header |
+| GGUF | | [`patterns/gguf.hexpat`](patterns/gguf.hexpat) | GGML Inference Models |
 | GIF | `image/gif` | [`patterns/gif.hexpat`](patterns/gif.hexpat) | GIF image files |
+| GLTF | `model/gltf-binary` | [`patterns/gltf.hexpat`](patterns/gltf.hexpat) | GL Transmission Format binary 3D model file |
 | GZIP | `application/gzip` | [`patterns/gzip.hexpat`](patterns/gzip.hexpat) | GZip compressed data format |
-| ICO | | [`patterns/ico.hexpat`](patterns/ico.hexpat) | Icon (.ico) or Cursor (.cur) files | 
+| Halo Tag || [`patterns/hinf_tag.hexpat`](patterns/hinf_tag.hexpat) | Halo Infinite Tag Files |
+| Halo Module || [`patterns/hinf_module.hexpat`](patterns/hinf_module.hexpat) | Halo Infinite Module Archive Files |
+| Halo HavokScript || [`patterns/hinf_luas.hexpat`](patterns/hinf_luas.hexpat) | Halo Infinite HavokScript 5.1 Bytecode |
+| HPROF || [`patterns/hprof.hexpat`](patterns/hprof.hexpat) | Java HPROF Profiler Data Format |
+| HSDT || [`patterns/hsdt.hexpat`](patterns/hsdt.hexpat) | HiSilicon device-tree table images |
+| ICO | | [`patterns/ico.hexpat`](patterns/ico.hexpat) | Icon (.ico) or Cursor (.cur) files |
 | ID3 | `audio/mpeg` | [`patterns/id3.hexpat`](patterns/id3.hexpat) | ID3 tags in MP3 files |
+| IM*H || [`patterns/imah.hexpat`](patterns/imah.hexpat) | DJI Signed Firmware (IM*H) |
 | Intel HEX  | | [`patterns/intel_hex.hexpat`](patterns/intel_hex.hexpat) | [Intel hexadecimal object file format definition]("https://en.wikipedia.org/wiki/Intel_HEX") |
-| IP | | [`patterns/ip.hexpat`](patterns/ip.hexpat) | Ethernet II Frames (IP Packets) | 
+| IP | | [`patterns/ip.hexpat`](patterns/ip.hexpat) | Ethernet II Frames (IP Packets) |
-| ISO | | [`patterns/iso.hexpat`](patterns/iso.hexpat) | ISO 9660 file system |
+| IPS | | [`patterns/ips.hexpat`](patterns/ips.hexpat) | IPS (International Patching System) files |
-| Java Class | `application/x-java-applet` | [`patterns/java_class.hexpat`](patterns/java_class.hexpat) | Java Class files | 
+| ISO | `application/x-iso9660-image` | [`patterns/iso.hexpat`](patterns/iso.hexpat) | ISO 9660 file system |
+| Java Class | `application/x-java-applet` | [`patterns/java_class.hexpat`](patterns/java_class.hexpat) | Java Class files |
 | JPEG | `image/jpeg` | [`patterns/jpeg.hexpat`](patterns/jpeg.hexpat) | JPEG Image Format |
+| LOC | | [`patterns/loc.hexpat`](patterns/loc.hexpat) | Minecraft Legacy Console Edition Language file |
+| Lua 5.1 | | [`patterns/lua51.hexpat`](patterns/lua51.hexpat) | Lua 5.1 bytecode |
+| Lua 5.2 | | [`patterns/lua52.hexpat`](patterns/lua52.hexpat) | Lua 5.2 bytecode |
+| Lua 5.3 | | [`patterns/lua53.hexpat`](patterns/lua53.hexpat) | Lua 5.3 bytecode |
 | Lua 5.4 | | [`patterns/lua54.hexpat`](patterns/lua54.hexpat) | Lua 5.4 bytecode |
+| LCE Savefile | | [`patterns/lcesave.hexpat`](patterns/lcesave.hexpat) | Minecraft Legacy Console Edition save file |
+| LZNT1 | | [`patterns/lznt1.hexpat`](patterns/lznt1.hexpat) | LZNT1 compressed data format |
 | Mach-O | `application/x-mach-binary` | [`patterns/macho.hexpat`](patterns/macho.hexpat) | Mach-O executable |
 | MIDI | `audio/midi` | [`patterns/midi.hexpat`](patterns/midi.hexpat) | MIDI header, event fields provided |
-| MiniDump | `application/x-dmp` | [`patterns/minidump.hexpat`](patterns/minidump.hexpat) | Windows MiniDump files | 
+| MiniDump | `application/x-dmp` | [`patterns/minidump.hexpat`](patterns/minidump.hexpat) | Windows MiniDump files |
-| mp4 | `video/mp4` | [`patterns/mp4.hexpat`](patterns/mp4.hexpat) | MPEG-4 Part 14 digital multimedia container format | 
+| MO | | [`patterns/mo.hexpat`](patterns/mo.hexpat) | GNU Machine Object (MO) files containing translations for gettext |
-| msgpack | `application/x-msgpack` | [`patterns/msgpack.hexpat`](patterns/msgpack.hexpat) | MessagePack binary serialization format | 
+| mp4 | `video/mp4` | [`patterns/mp4.hexpat`](patterns/mp4.hexpat) | MPEG-4 Part 14 digital multimedia container format |
-| NACP | | [`patterns/nacp.hexpat`](patterns/nacp.hexpat) | Nintendo Switch NACP files | 
+| msgpack | `application/x-msgpack` | [`patterns/msgpack.hexpat`](patterns/msgpack.hexpat) | MessagePack binary serialization format |
+| MSSCMP | | [`patterns/msscmp.hexpat`](patterns/msscmp.hexpat) | Miles Sound System Compressed Archive |
+| NACP | | [`patterns/nacp.hexpat`](patterns/nacp.hexpat) | Nintendo Switch NACP files |
 | NBT | | [`patterns/nbt.hexpat`](patterns/nbt.hexpat) | Minecraft NBT format |
-| NE   | | [`patterns/ne.hexpat`](patterns/ne.hexpat) | NE header and Standard NE fields |
+| NDS | `application/x-nintendo-ds-rom` | [`patterns/nds.hexpat`](patterns/nds.hexpat) | DS Cartridge Header |
-| NRO | | [`patterns/nro.hexpat`](patterns/nro.hexpat) | Nintendo Switch NRO files | 
+| NE | `application/x-ms-ne-executable` | [`patterns/ne.hexpat`](patterns/ne.hexpat) | NE header and Standard NE fields |
-| NTAG | | [`patterns/ntag.hexpat`](patterns/ntag.hexpat) | NTAG213/NTAG215/NTAG216, NFC Forum Type 2 Tag compliant IC | 
+| nes | | [`patterns/nes.hexpat`](patterns/nes.hexpat) | .nes file format |
-| OGG | `audio/ogg` | [`patterns/ogg.hexpat`](patterns/ogg.hexpat) | OGG Audio format | 
+| NotepadCache | | [`patterns/notepad-cache.hexpat`](patterns/notepad-cache.hexpat) | Windows Notepad Cache |
-| PCAP | `application/vnd.tcpdump.pcap` | [`patterns/pcap.hexpat`](patterns/pcap.hexpat) | pcap header and packets | 
+| NotepadWindowState | | [`patterns/notepadwindowstate.hexpat`](patterns/notepadwindowstate.hexpat) | Windows 11 Notepad - Window State .bin file |
+| NRO | | [`patterns/nro.hexpat`](patterns/nro.hexpat) | Nintendo Switch NRO files |
+| NTAG | | [`patterns/ntag.hexpat`](patterns/ntag.hexpat) | NTAG213/NTAG215/NTAG216, NFC Forum Type 2 Tag compliant IC |
+| NTFS | | [`patterns/fs/ntfs.hexpat`](patterns/fs/ntfs.hexpat) | NTFS (NT File System) |
+| OGG | `audio/ogg` | [`patterns/ogg.hexpat`](patterns/ogg.hexpat) | OGG Audio format |
+| ORP / ORS | | [`patterns/orp.hexpat`](patterns/orp.hexpat) | OpenRGB profile format |
+| PACK | | [`patterns/roblox_pack.hexpat`](patterns/roblox_pack.hexpat) | Roblox shader archive format |
+| PAK | | [`patterns/xgspak.hexpat`](patterns/xgspak.hexpat) | Exient XGS Engine Pak files |
+| PCAP | `application/vnd.tcpdump.pcap` | [`patterns/pcap.hexpat`](patterns/pcap.hexpat) | pcap header and packets |
+| PcapNG | `application/vnd.tcpdump.pcap` | [`patterns/pcapng.hexpat`](patterns/pcapng.hexpat) | pcapng header and packets |
+| PCK | | [`patterns/pck.hexpat`](patterns/pck.hexpat) | Minecraft Legacy Console Edition .pck file |
 | PCX | `application/x-pcx` | [`patterns/pcx.hexpat`](patterns/pcx.hexpat) | PCX Image format |
-| PE   | `application/x-dosexec` | [`patterns/pe.hexpat`](patterns/pe.hexpat) | PE header, COFF header, Standard COFF fields and Windows Specific fields |
+| PE | `application/x-dosexec` `application/x-msdownload` | [`patterns/pe.hexpat`](patterns/pe.hexpat) | PE header, COFF header, Standard COFF fields and Windows Specific fields |
+| PEF | | [`patterns/pef.hexpat`](patterns/pef.hexpat) | Preffered Executable Format executable (for Mac OS 7.1.2 - Mac OS 10.4 / BeOS) |
+| PEX | | [`patterns/pex.hexpat`](patterns/pex.hexpat) | Bethesda Papyrus executable compiled script file |
+| PP | | [`patterns/selinuxpp.hexpat`](patterns/selinuxpp.pat) | SE Linux package |
 | PFS0 | | [`patterns/pfs0.hexpat`](patterns/pfs0.hexpat) | Nintendo Switch PFS0 archive (NSP files) |
+| PF | | [`patterns/pf.hexpat`](patterns/pf.hexpat) | Microsoft uncompressed prefetch files (.pf) |
 | PIF | `image/pif` | [`patterns/pif.hexpat`](patterns/pif.hexpat) | PIF Image Format |
-| PNG  | `image/png` | [`patterns/png.hexpat`](patterns/png.hexpat) | PNG image files | 
+| PKM | | [`patterns/pkm.hexpat`](patterns/pkm.hexpat) | PKM texture format |
-| PRODINFO | | [`patterns/prodinfo.hexpat`](patterns/prodinfo.hexpat) | Nintendo Switch PRODINFO | 
+| PNG  | `image/png` | [`patterns/png.hexpat`](patterns/png.hexpat) | PNG image files |
-| Protobuf | | [`patterns/protobuf.hexpat`](patterns/protobuf.hexpat) | Google Protobuf encoding | 
+| PRODINFO | | [`patterns/prodinfo.hexpat`](patterns/prodinfo.hexpat) | Nintendo Switch PRODINFO |
+| Protobuf | | [`patterns/protobuf.hexpat`](patterns/protobuf.hexpat) | Google Protobuf encoding |
+| psafe3 | | [`patterns/psafe3.hexpat`](patterns/psafe3.hexpat`) | Password Safe V3 |
+| PyInstaller | | [`patterns/pyinstaller.hexpat`](patterns/pyinstaller.hexpat) | PyInstaller binray files |
+| PYC | `application/x-bytecode.python` | [`patterns/pyc.hexpat`](patterns/pyc.hexpat) | Python bytecode files |
 | QBCL | | [`patterns/qbcl.hexpat`](patterns/qbcl.hexpat) | Qubicle voxel scene project file |
-| QOI  | `image/qoi` | [`patterns/qoi.hexpat`](patterns/qoi.hexpat) | QOI image files | 
+| QOI | `image/qoi` | [`patterns/qoi.hexpat`](patterns/qoi.hexpat) | QOI image files |
-| Shell Link | `application/x-ms-shortcut` | [`patterns/lnk.hexpat`](patterns/lnk.hexpat) | Windows Shell Link file format | 
+| Quake 3 engine demo | | [`patterns/q3demo.hexpat`](patterns/q3demo.hexpat) | Demos/replays of most Quake 3 engine games |
-| SPIRV | | [`patterns/spirv.hexpat`](patterns/spirv.hexpat) | SPIR-V header and instructions | 
+| quantized-mesh | | [`patterns/quantized-mesh.hexpat`](patterns/quantized-mesh.hexpat) | Cesium quantized-mesh terrain |
-| STL | `model/stl` | [`patterns/stl.hexpat`](patterns/stl.hexpat) | STL 3D Model format | 
+| RAR | `application/x-rar` | [`patterns/rar.hexpat`](patterns/rar.hexpat) | RAR archive file format |
+| RAS | `image/x-sun-raster` | [`patterns/ras.hexpat`](patterns/ras.hexpat) | RAS image files |
+| RCF 1.2 | | [`patterns/rcf_v1_2.hexpat`](patterns/rcf_v1_2.hexpat) | Radcore Cement Library 1.2 file header |
+| ReFS | | [`patterns/refs.hexpat`](patterns/fs/refs.hexpat) | Microsoft Resilient File System |
+| RGBDS | | [`patterns/rgbds.hexpat`](patterns/rgbds.hexpat) | [RGBDS](https://rgbds.gbdev.io) object file format |
+| RPM | | [`patterns/rpm.hexpat`](patterns/rpm.hexpat) | [RPM](http://ftp.rpm.org/max-rpm/s1-rpm-file-format-rpm-file-format.html) package file format |
+| SDB | | [`patterns/sdb.hexpat`](patterns/sdb.hexpat) | [Shim DataBase](https://learn.microsoft.com/en-us/windows/win32/devnotes/application-compatibility-database) file format |
+| Shell Link | `application/x-ms-shortcut` | [`patterns/lnk.hexpat`](patterns/lnk.hexpat) | Windows Shell Link file format |
+| shp | | [`patterns/shp.hexpat`](patterns/shp.hexpat) | ESRI shape file |
+| SHR | | [`patterns/SHR.hexpat`](patterns/SHR.hexpat) | Apple IIgs Super Hi-Res (SHR) + PaintWorks Animation (ANI) |
+| shx | | [`patterns/shx.hexpat`](patterns/shx.hexpat) | ESRI index file |
+| smk | | [`patterns/smk.hexpat`](patterns/smk.hexpat) | Smacker video file |
+| sup | | [`patterns/sup.hexpat`](patterns/sup.hexpat) | PGS Subtitle |
+| SPIRV | | [`patterns/spirv.hexpat`](patterns/spirv.hexpat) | SPIR-V header and instructions |
+| STDF | | [`patterns/stdfv4.hexpat`](patterns/stdfv4.hexpat) | Standard test data format for IC testers |
+| STL | `model/stl` | [`patterns/stl.hexpat`](patterns/stl.hexpat) | STL 3D Model format |
 | StuffItV5 | `application/x-stuffit` | [`patterns/sit5.hexpat`](patterns/sit5.hexpat) | StuffIt V5 archive |
+| SQLite3 | `application/vnd.sqlite3` | [`patterns/sqlite3.hexpat`](patterns/sqlite3.hexpat) | SQLite3 Database |
+| SWF | `application/x-shockwave-flash` |[`patterns/swf.hexpat`](patterns/swf.hexpat) | Shockwave Flash file format |
+| TA | | [`patterns/optee_ta.hexpat`](patterns/optee_ta.hexpat) | OPTEE Trusted Application Executable |
 | TAR | `application/x-tar` | [`patterns/tar.hexpat`](patterns/tar.hexpat) | Tar file format |
+| TARC | | [`patterns/tarc.hexpat`](patterns/tarc.hexpat) | KEX Engine TARC file format |
+| TES | | [`patterns/wintec_tes.hexpat`](patterns/wintec_tes.hexpat) | Wintec TES GPS log |
+| Thumbcache | | [`patterns/thumbcache.hexpat`](patterns/thumbcache.hexpat) | Windows thumbcache_*.db |
 | TIFF | `image/tiff` | [`patterns/tiff.hexpat`](patterns/tiff.hexpat) | Tag Image File Format |
 | TGA | `image/tga` | [`patterns/tga.hexpat`](patterns/tga.hexpat) | Truevision TGA/TARGA image |
+| TTF | `font/ttf`, `font/otf` | [`patterns/ttf.hexpat`](patterns/ttf.hexpat) | TrueType and OpenType font format |
+| Ubiquiti | | [`patterns/ubiquiti.hexpat`](patterns/ubiquiti.hexpat) | Ubiquiti Firmware (update) image |
+| UPK | | [`patterns/upk-ue3.hexpat`](patterns/upk-ue3.hexpat) | Unreal Engine 3 UPK file |
 | UEFI | | [`patterns/uefi.hexpat`](patterns/uefi.hexpat)` | UEFI structs for parsing efivars |
-| UF2 | | [`patterns/uf2.hexpat`](patterns/uf2.hexpat) | [USB Flashing Format](https://github.com/microsoft/uf2) | 
+| UEFI Boot Entry | | [`patterns/uefi_boot_entry.hexpat`](patterns/uefi_boot_entry.hexpat) | UEFI Boot Entry (Load option) |
-| VDF | | [`patterns/vdf.hexpat`](patterns/vdf.hexpat) | Binary Value Data Format (.vdf) files | 
+| UEFI Variable Store | | [`patterns/uefi_fv_varstore.hexpat`](patterns/uefi_fv_varstore.hexpat) | UEFI Firmware Volume Variable Store |
-| VHDX | | [`patterns/vhdx.hexpat`](patterns/vhdx.hexpat) | Microsoft Hyper-V Virtual Hard Disk format | 
+| UF2 | | [`patterns/uf2.hexpat`](patterns/uf2.hexpat) | [USB Flashing Format](https://github.com/microsoft/uf2) |
+| Valve VPK | | [`patterns/valve_vpk.hexpat`](valve_vpk.hexpat) | Valve Package File |
+| VBMeta | | [`patterns/vbmeta.hexpat`](patterns/vbmeta.hexpat) | Android VBMeta image |
+| VDF | | [`patterns/vdf.hexpat`](patterns/vdf.hexpat) | Binary Value Data Format (.vdf) files |
+| VEADO | | [`patterns/veado.hexpat`](patterns/veado.hexpat) | veadotube mini avatar file |
+| VGM | | [`patterns/vgm.hexpat`](patterns/vgm.hexpat) | VGM (Video Game Music) sound log |
+| VHDX | | [`patterns/vhdx.hexpat`](patterns/vhdx.hexpat) | Microsoft Hyper-V Virtual Hard Disk format |
+| VOX | | [`patterns/vox.hexpat`](patterns/vox.hexpat) | MagicaVoxel scene description format |
 | WAV  | `audio/x-wav`  | [`patterns/wav.hexpat`](patterns/wav.hexpat)  | RIFF header, WAVE header, PCM header |
+| WAS | | [`patterns/was_oskasoftware.hexpat`](patterns/was_oskasoftware.hexpat) | Oska Software DeskMates WAS/WA3 (WAVE/MP3 Set) file
 | WAD | | [`patterns/wad.hexpat`](patterns/wad.hexpat) | DOOM WAD Archive |
+| WebP | `image/webp` | [`patterns/webp.hexpat`](patterns/webp.hexpat) | Google WebP image |
 | XBEH | `audio/x-xbox-executable` | [`patterns/xbeh.hexpat`](patterns/xbeh.hexpat) | Xbox executable |
-| XCI | | [`patterns/xci.hexpat`](patterns/xci.hexpat) | Nintendo Switch XCI cardridge ROM |
+| XCI | | [`patterns/xci.hexpat`](patterns/xci.hexpat) | Nintendo Switch XCI cartridge ROM |
-| Xilinx BIT | | [`patterns/xilinx_bit.hexpat`](patterns/xilinx_bit.hexpat) | Xilinx FPGA Bitstreams | 
+| XGT | | [`patterns/xgt.hexpat`](patterns/xgstexture.hexpat) | Exient XGS Engine Texture |
+| Xilinx BIT | | [`patterns/xilinx_bit.hexpat`](patterns/xilinx_bit.hexpat) | Xilinx FPGA Bitstreams |
+| Xilinx Bootgen | `application/x-xilinx-boot-zynqmp` | [`patterns/xilinx_bootgen.hexpat`](patterns/xilinx_bootgen.hexpat) | Xilinx ZynqMP Boot Images |
+| ZIM  | | [`patterns/zim.hexpat`](patterns/zim.hexpat) | [ZIM](https://openzim.org) file format |
 | ZIP  | `application/zip` | [`patterns/zip.hexpat`](patterns/zip.hexpat) | End of Central Directory Header, Central Directory File Headers |
+| ZLIB | `application/zlib` | [`patterns/zlib.hexpat`](patterns/zlib.hexpat) | ZLIB compressed data format |
 | ZSTD | `application/zstd` | [`patterns/zstd.hexpat`](patterns/zstd.hexpat) | Zstandard compressed data format |
+| MOD | `3d-model/mod` | [`patterns/DMC3HD-Mod.hexpat`](patterns/dmc3_hd_mod.hexpat) | 3D Model files used in Devil May Cry 3 HD Collection |
+| CBM BASIC | | [`commodore_basic.hexpat`](patterns/commodore_basic.hexpat) | Commodore BASIC |
 
 ### Scripts
 
@@ -110,9 +220,9 @@ Everything will immediately show up in ImHex's Content Store and gets bundled wi
 
 | Name | Path | Description |
 |------|------|-------------|
-| libstd | [`includes/std/*`](includes/std) | Pattern Language Standard Libaray |
-| libtype | [`includes/type/*`](includes/type) | Various custom types with special formatters |
 | libhex | [`includes/hex/*`](includes/hex) | Functions to interact with ImHex |
+| libstd | [`includes/std/*`](includes/std) | Pattern Language Standard Library |
+| libtype | [`includes/type/*`](includes/type) | Various custom types with special formatters |
 
 ### Yara rules
 
@@ -147,6 +257,7 @@ Everything will immediately show up in ImHex's Content Store and gets bundled wi
 | ASCII+OEM | [`encodings/ascii_oem.tbl`](encodings/ascii_oem.tbl) | ASCII encoding with Windows OEM characters |
 | Baltic ISO | [`encodings/baltic_iso.tbl`](encodings/baltic_iso.tbl) | Baltic ISO encoding |
 | Baltic Windows | [`encodings/baltic_windows.tbl`](encodings/baltic_windows.tbl) | Baltic Windows encoding |
+| Big5 (Traditional Chinese) | [`encodings/big5.tbl`](encodings/big5.tbl) | Big5 encoding for Traditional Chinese |
 | Cyrillic ISO | [`encodings/cyrillic_iso.tbl`](encodings/cyrillic_iso.tbl) | Cyrillic ISO encoding |
 | Cyrillic Windows | [`encodings/cyrillic_windows.tbl`](encodings/cyrillic_windows.tbl) | Cyrillic Windows encoding |
 | Cyrillic KOI8-R | [`encodings/cyrillic_koi8_r.tbl`](encodings/cyrillic_koi8_r.tbl) | Cyrillic KOI8-R encoding (Russian Characters) |
@@ -176,12 +287,14 @@ Everything will immediately show up in ImHex's Content Store and gets bundled wi
 | Vietnamese | [`encodings/vietnamese.tbl`](encodings/vietnamese.tbl) | Vietnamese character encoding |
 
 ### Data Processor Nodes
+
 | Name | Path | Description |
 |------|------|-------------|
 | Caesar Cipher | [`nodes/caesar.hexnode`](nodes/caesar.hexnode) | Simple adjustable per-byte Caecar Cipher (ROT) |
 | XOR Cipher | [`nodes/xor.hexnode`](nodes/xor.hexnode) | XORs a input with a repeating XOR pad |
 
 ### Themes
+
 | Name | Path | Description |
 |------|------|-------------|
 | Visual Studio Dark | [`themes/vs_dark.json`](themes/vs_dark.json) | Theme similar to Visual Studio's Dark theme |
@@ -190,3 +303,11 @@ Everything will immediately show up in ImHex's Content Store and gets bundled wi
 | Catppuccin Frappe | [`themes/catppuccin-frappe.json`](themes/catppuccin-frappe.json) | Catppuccin Frappe Flavor (Dark Theme) |
 | Catppuccin Macchiato | [`themes/catppuccin-macchiato.json`](themes/catppuccin-macchiato.json) | Catppuccin Macchiato Flavor (Dark Theme) |
 | Catppuccin Mocha | [`themes/catppuccin-mocha.json`](themes/catppuccin-mocha.json) | Catppuccin Mocha Flavor (Dark Theme) |
+| Theme Lion | [`themes/theme_lion.json`](themes/theme_lion.json) | Semantic CLion inspired theme (Dark Theme) |
+| Retina Dark | [`themes/retina_dark.json`](themes/retina_dark.json) | Semantic theme based on Dark Theme |
+
+### Disassemblers
+
+| Name | Path | Description |
+|------|------|-------------|
+| 8051 | [`disassemblers/8051.json`](disassemblers/8051.json) | Intel 8051 Architecture |

constants/linux_errors.json

@@ -775,6 +775,6 @@
             "name": "ENOTRECOVERABLE",
             "desc": "State not recoverable"
         }
-        
+
     ]
 }

disassemblers/8051.json

@@ -0,0 +1,730 @@
+{
+    "name": "Intel 8051",
+    "includes": [],
+    "options": [],
+    "opcodes": [
+        {
+            "mask": "0000'0000",
+            "mnemonic": "NOP",
+            "format": ""
+        },
+        {
+            "mask": "0000'0010 AAAA'AAAA AAAA'AAAA",
+            "mnemonic": "LJMP",
+            "format": "#0x{A:04X}",
+            "metadata": [
+                {
+                    "type": "jump",
+                    "data": {
+                        "destination": "A"
+                    }
+                }
+            ]
+        },
+        {
+            "mask": "1000'0000 AAAA'AAAA",
+            "mnemonic": "SJMP",
+            "format": "#0x{A:02X}",
+            "metadata": [
+                {
+                    "type": "jump",
+                    "data": {
+                        "destination": "A"
+                    }
+                }
+            ]
+        },
+        {
+            "mask": "0111'0011",
+            "mnemonic": "JMP",
+            "format": "@A+DPTR"
+        },
+        {
+            "mask": "0100'0000 AAAA'AAAA",
+            "mnemonic": "JC",
+            "format": "PC + 0x{A:02X}",
+            "metadata": [
+                {
+                    "type": "jump",
+                    "data": {
+                        "destination": "offset + 2 + A"
+                    }
+                }
+            ]
+        },
+        {
+            "mask": "0011'0000 BBBB'BBBB AAAA'AAAA",
+            "mnemonic": "JNB",
+            "format": "BIT[0x{B:02X}], PC + 0x{A:02X}",
+            "metadata": [
+                {
+                    "type": "jump",
+                    "data": {
+                        "destination": "offset + 3 + A"
+                    }
+                }
+            ]
+        },
+        {
+            "mask": "0001'0000 BBBB'BBBB AAAA'AAAA",
+            "mnemonic": "JBC",
+            "format": "BIT[0x{B:02X}], PC + 0x{A:02X}",
+            "metadata": [
+                {
+                    "type": "jump",
+                    "data": {
+                        "destination": "offset + 3 + A"
+                    }
+                }
+            ]
+        },
+        {
+            "mask": "0010'0000 AAAA'AAAA RRRR'RRRR",
+            "mnemonic": "JB",
+            "format": "BIT[0x{A:02X}], PC + 0x{R:02X}",
+            "metadata": [
+                {
+                    "type": "jump",
+                    "data": {
+                        "destination": "offset + 3 + A"
+                    }
+                }
+            ]
+        },
+        {
+            "mask": "0001'0010 AAAA'AAAA AAAA'AAAA",
+            "mnemonic": "LCALL",
+            "format": "#0x{A:04X}",
+            "metadata": [
+                {
+                    "type": "jump",
+                    "data": {
+                        "destination": "A"
+                    }
+                }
+            ]
+        },
+        {
+            "mask": "PPP1'0001 AAAA'AAAA",
+            "mnemonic": "ACALL",
+            "format": "page{P} #0x{A:04X}",
+            "metadata": [
+                {
+                    "type": "jump",
+                    "data": {
+                        "destination": "P * 256 + A"
+                    }
+                }
+            ]
+        },
+        {
+            "mask": "PPP0'0001 AAAA'AAAA",
+            "mnemonic": "AJMP",
+            "format": "page{P} #0x{A:04X}",
+            "metadata": [
+                {
+                    "type": "jump",
+                    "data": {
+                        "destination": "P * 256 + A"
+                    }
+                }
+            ]
+        },
+        {
+            "mask": "0000'0011",
+            "mnemonic": "RR",
+            "format": "A"
+        },
+        {
+            "mask": "0001'0011",
+            "mnemonic": "RRC",
+            "format": "A"
+        },
+        {
+            "mask": "0010'0011",
+            "mnemonic": "RL",
+            "format": "A"
+        },
+        {
+            "mask": "0011'0011",
+            "mnemonic": "RLC",
+            "format": "A"
+        },
+        {
+            "mask": "0000'0100",
+            "mnemonic": "INC",
+            "format": "A"
+        },
+        {
+            "mask": "0000'0101 AAAA'AAAA",
+            "mnemonic": "INC",
+            "format": "IRAM[0x{A:02X}]"
+        },
+        {
+            "mask": "0000'011R",
+            "mnemonic": "INC",
+            "format": "@R{R}"
+        },
+        {
+            "mask": "0000'1RRR",
+            "mnemonic": "INC",
+            "format": "R{R}"
+        },
+        {
+            "mask": "1010'0011",
+            "mnemonic": "INC",
+            "format": "DPTR"
+        },
+        {
+            "mask": "0001'0100",
+            "mnemonic": "DEC",
+            "format": "A"
+        },
+        {
+            "mask": "0001'0101 AAAA'AAAA",
+            "mnemonic": "DEC",
+            "format": "IRAM[0x{A:02X}]"
+        },
+        {
+            "mask": "0001'0110",
+            "mnemonic": "DEC",
+            "format": "@R0"
+        },
+        {
+            "mask": "0001'0111",
+            "mnemonic": "DEC",
+            "format": "@R1"
+        },
+        {
+            "mask": "0001'1RRR",
+            "mnemonic": "DEC",
+            "format": "R{R}"
+        },
+        {
+            "mask": "1110'0100",
+            "mnemonic": "CLR",
+            "format": "A"
+        },
+        {
+            "mask": "1100'0010 AAAA'AAAA",
+            "mnemonic": "CLR",
+            "format": "BIT[0x{A:02X}]"
+        },
+        {
+            "mask": "1100'0011",
+            "mnemonic": "CLR",
+            "format": "C"
+        },
+        {
+            "mask": "1111'0000",
+            "mnemonic": "MOVX",
+            "format": "@DPTR, A"
+        },
+        {
+            "mask": "1110'0000",
+            "mnemonic": "MOVX",
+            "format": "A, @DPTR"
+        },
+        {
+            "mask": "1111'001R",
+            "mnemonic": "MOVX",
+            "format": "@R{R}, A"
+        },
+        {
+            "mask": "1110'001R",
+            "mnemonic": "MOVX",
+            "format": "A, @R{R}"
+        },
+        {
+            "mask": "0111'011R AAAA'AAAA",
+            "mnemonic": "MOV",
+            "format": "@R{R}, #0x{A:02X}"
+        },
+        {
+            "mask": "0111'1RRR AAAA'AAAA",
+            "mnemonic": "MOV",
+            "format": "R{R}, #0x{A:02X}"
+        },
+        {
+            "mask": "1111'1RRR",
+            "mnemonic": "MOV",
+            "format": "R{R}, A"
+        },
+        {
+            "mask": "1110'011R",
+            "mnemonic": "MOV",
+            "format": "A, @R{R}"
+        },
+        {
+            "mask": "1111'011R",
+            "mnemonic": "MOV",
+            "format": "@R{R}, A"
+        },
+        {
+            "mask": "1110'1RRR",
+            "mnemonic": "MOV",
+            "format": "A, R{R}"
+        },
+        {
+            "mask": "1001'0010 AAAA'AAAA",
+            "mnemonic": "MOV",
+            "format": "BIT[0x{A:02X}], C"
+        },
+        {
+            "mask": "1010'0010 AAAA'AAAA",
+            "mnemonic": "MOV",
+            "format": "C, BIT[0x{A:02X}]"
+        },
+        {
+            "mask": "1001'0000 DDDD'DDDD DDDD'DDDD",
+            "mnemonic": "MOV",
+            "format": "DPTR, #0x{D:04X}"
+        },
+        {
+            "mask": "1110'0101 AAAA'AAAA",
+            "mnemonic": "MOV",
+            "format": "A, IRAM[0x{A:02X}]"
+        },
+        {
+            "mask": "1111'0101 AAAA'AAAA",
+            "mnemonic": "MOV",
+            "format": "IRAM[#0x{A:02X}], A"
+        },
+        {
+            "mask": "0111'0101 AAAA'AAAA DDDD'DDDD",
+            "mnemonic": "MOV",
+            "format": "IRAM[0x{A:02X}], #0x{D:02X}"
+        },
+        {
+            "mask": "1000'0101 AAAA'AAAA BBBB'BBBB",
+            "mnemonic": "MOV",
+            "format": "IRAM[0x{A:02X}], IRAM[0x{B:02X}]"
+        },
+        {
+            "mask": "0111'0100 DDDD'DDDD",
+            "mnemonic": "MOV",
+            "format": "A, #0x{D:02X}"
+        },
+        {
+            "mask": "1000'011R AAAA'AAAA",
+            "mnemonic": "MOV",
+            "format": "IRAM[0x{A:02X}], @R{R}"
+        },
+        {
+            "mask": "1000'1RRR AAAA'AAAA",
+            "mnemonic": "MOV",
+            "format": "IRAM[0x{A:02X}], R{R}"
+        },
+        {
+            "mask": "1010'011R AAAA'AAAA",
+            "mnemonic": "MOV",
+            "format": "@R{R}, IRAM[0x{A:02X}]"
+        },
+        {
+            "mask": "1010'1RRR AAAA'AAAA",
+            "mnemonic": "MOV",
+            "format": "R{R}, IRAM[0x{A:02X}]"
+        },
+        {
+            "mask": "0110'0000 AAAA'AAAA",
+            "mnemonic": "JZ",
+            "format": "PC + 0x{A:02X}",
+            "metadata": [
+                {
+                    "type": "jump",
+                    "data": {
+                        "destination": "offset + 2 + A"
+                    }
+                }
+            ]
+        },
+        {
+            "mask": "0111'0000 AAAA'AAAA",
+            "mnemonic": "JNZ",
+            "format": "PC + 0x{A:02X}",
+            "metadata": [
+                {
+                    "type": "jump",
+                    "data": {
+                        "destination": "offset + 2 + A"
+                    }
+                }
+            ]
+        },
+        {
+            "mask": "1001'0011",
+            "mnemonic": "MOVC",
+            "format": "A, @A+DPTR"
+        },
+        {
+            "mask": "1000'0011",
+            "mnemonic": "MOVC",
+            "format": "A, @A+PC"
+        },
+        {
+            "mask": "1101'011R",
+            "mnemonic": "XCHD",
+            "format": "A, @R{R}"
+        },
+        {
+            "mask": "1100'011R",
+            "mnemonic": "XCH",
+            "format": "A, @R{R}"
+        },
+        {
+            "mask": "1100'1RRR",
+            "mnemonic": "XCH",
+            "format": "A, R{R}"
+        },
+        {
+            "mask": "1100'0101 AAAA'AAAA",
+            "mnemonic": "XCH",
+            "format": "A, IRAM[0x{A:02X}]"
+        },
+        {
+            "mask": "0010'0010",
+            "mnemonic": "RET",
+            "format": ""
+        },
+        {
+            "mask": "0011'0010",
+            "mnemonic": "RETI",
+            "format": ""
+        },
+        {
+            "mask": "1101'0010 AAAA'AAAA",
+            "mnemonic": "SETB",
+            "format": "BIT[0x{A:02X}]"
+        },
+        {
+            "mask": "1101'0011",
+            "mnemonic": "SETB",
+            "format": "C"
+        },
+        {
+            "mask": "0101'0010 AAAA'AAAA",
+            "mnemonic": "ANL",
+            "format": "IRAM[0x{A:02X}], A"
+        },
+        {
+            "mask": "0101'0101 AAAA'AAAA",
+            "mnemonic": "ANL",
+            "format": "A, IRAM[0x{A:02X}]"
+        },
+        {
+            "mask": "0101'0011 AAAA'AAAA DDDD'DDDD",
+            "mnemonic": "ANL",
+            "format": "A, IRAM[0x{A:02X}], #0x{D:02X}"
+        },
+        {
+            "mask": "0101'0100 AAAA'AAAA",
+            "mnemonic": "ANL",
+            "format": "A, #0x{A:02X}"
+        },
+        {
+            "mask": "0101'011R",
+            "mnemonic": "ANL",
+            "format": "A, @R{R}"
+        },
+        {
+            "mask": "0101'1RRR",
+            "mnemonic": "ANL",
+            "format": "A, R{R}"
+        },
+        {
+            "mask": "1000'0010 AAAA'AAAA",
+            "mnemonic": "ANL",
+            "format": "C, BIT[0x{A:02X}]"
+        },
+        {
+            "mask": "1011'0000 AAAA'AAAA",
+            "mnemonic": "ANL",
+            "format": "C, /BIT[0x{A:02X}]"
+        },
+        {
+            "mask": "0100'0010 AAAA'AAAA",
+            "mnemonic": "ORL",
+            "format": "IRAM[0x{A:02X}], A"
+        },
+        {
+            "mask": "0100'0011 AAAA'AAAA DDDD'DDDD",
+            "mnemonic": "ORL",
+            "format": "IRAM[0x{A:02X}], #0x{D:02X}"
+        },
+        {
+            "mask": "0100'0100 DDDD'DDDD",
+            "mnemonic": "ORL",
+            "format": "A, #0x{D:02X}"
+        },
+        {
+            "mask": "0100'011R",
+            "mnemonic": "ORL",
+            "format": "A, @R{R}"
+        },
+        {
+            "mask": "0100'1RRR",
+            "mnemonic": "ORL",
+            "format": "A, R{R}"
+        },
+        {
+            "mask": "0100'0101 AAAA'AAAA",
+            "mnemonic": "ORL",
+            "format": "A, IRAM[0x{A:02X}]"
+        },
+        {
+            "mask": "0111'0010 AAAA'AAAA",
+            "mnemonic": "ORL",
+            "format": "C, BIT[0x{A:02X}]"
+        },
+        {
+            "mask": "1010'0000 AAAA'AAAA",
+            "mnemonic": "ORL",
+            "format": "C, /BIT[0x{A:02X}]"
+        },
+        {
+            "mask": "0110'0010 AAAA'AAAA",
+            "mnemonic": "XRL",
+            "format": "IRAM[0x{A:02X}], A"
+        },
+        {
+            "mask": "0110'0011 AAAA'AAAA DDDD'DDDD",
+            "mnemonic": "XRL",
+            "format": "IRAM[0x{A:02X}], #0x{D:02X}"
+        },
+        {
+            "mask": "0110'0100 DDDD'DDDD",
+            "mnemonic": "XRL",
+            "format": "A, #0x{D:02X}"
+        },
+        {
+            "mask": "0110'011R",
+            "mnemonic": "XRL",
+            "format": "A, @R{R}"
+        },
+        {
+            "mask": "0110'1RRR",
+            "mnemonic": "XRL",
+            "format": "A, R{R}"
+        },
+        {
+            "mask": "0110'0101 AAAA'AAAA",
+            "mnemonic": "XRL",
+            "format": "A, IRAM[0x{A:02X}]"
+        },
+        {
+            "mask": "0010'0100 DDDD'DDDD",
+            "mnemonic": "ADD",
+            "format": "A, #0x{D:02X}"
+        },
+        {
+            "mask": "0010'011R",
+            "mnemonic": "ADD",
+            "format": "A, @R{R}"
+        },
+        {
+            "mask": "0010'0101 AAAA'AAAA",
+            "mnemonic": "ADD",
+            "format": "A, IRAM[0x{A:02X}]"
+        },
+        {
+            "mask": "0011'0100 DDDD'DDDD",
+            "mnemonic": "ADDC",
+            "format": "A, #0x{D:02X}"
+        },
+        {
+            "mask": "0011'011R",
+            "mnemonic": "ADDC",
+            "format": "A, @R{R}"
+        },
+        {
+            "mask": "0011'0101 AAAA'AAAA",
+            "mnemonic": "ADDC",
+            "format": "A, IRAM[0x{A:02X}]"
+        },
+        {
+            "mask": "0011'1RRR",
+            "mnemonic": "ADDC",
+            "format": "A, R{R}"
+        },
+        {
+            "mask": "1001'0100 DDDD'DDDD",
+            "mnemonic": "SUBB",
+            "format": "A, #0x{D:02X}"
+        },
+        {
+            "mask": "1001'0101 IIII'IIII",
+            "mnemonic": "SUBB",
+            "format": "A, IRAM[0x{I:02X}]"
+        },
+        {
+            "mask": "1001'011R",
+            "mnemonic": "SUBB",
+            "format": "A, @R{R}"
+        },
+        {
+            "mask": "1001'1RRR",
+            "mnemonic": "SUBB",
+            "format": "A, R{R}"
+        },
+        {
+            "mask": "1010'0100",
+            "mnemonic": "MUL",
+            "format": "AB"
+        },
+        {
+            "mask": "1000'0100",
+            "mnemonic": "DIV",
+            "format": "AB"
+        },
+        {
+            "mask": "0010'1RRR",
+            "mnemonic": "ORL",
+            "format": "A, R{R}"
+        },
+        {
+            "mask": "1011'0101 IIII'IIII AAAA'AAAA",
+            "mnemonic": "CJNE",
+            "format": "A, IRAM[0x{I:02X}], PC + 0x{A:02X}",
+            "metadata": [
+                {
+                    "type": "jump",
+                    "data": {
+                        "destination": "offset + 3 + A"
+                    }
+                }
+            ]
+        },
+        {
+            "mask": "1011'0100 DDDD'DDDD AAAA'AAAA",
+            "mnemonic": "CJNE",
+            "format": "A, #0x{D:02X}, PC + 0x{A:02X}",
+            "metadata": [
+                {
+                    "type": "jump",
+                    "data": {
+                        "destination": "offset + 3 + A"
+                    }
+                }
+            ]
+        },
+        {
+            "mask": "1011'011R DDDD'DDDD AAAA'AAAA",
+            "mnemonic": "CJNE",
+            "format": "@R{R}, #0x{D:02X}, PC + 0x{A:02X}",
+            "metadata": [
+                {
+                    "type": "jump",
+                    "data": {
+                        "destination": "offset + 3 + A"
+                    }
+                }
+            ]
+        },
+        {
+            "mask": "1011'1RRR DDDD'DDDD AAAA'AAAA",
+            "mnemonic": "CJNE",
+            "format": "R{R}, #0x{D:02X}, PC + 0x{A:02X}",
+            "metadata": [
+                {
+                    "type": "jump",
+                    "data": {
+                        "destination": "offset + 3 + A"
+                    }
+                }
+            ]
+        },
+        {
+            "mask": "1101'0101 IIII'IIII AAAA'AAAA",
+            "mnemonic": "DJNZ",
+            "format": "IRAM[0x{I:02X}], PC + 0x{A:02X}",
+            "metadata": [
+                {
+                    "type": "jump",
+                    "data": {
+                        "destination": "offset + 3 + A"
+                    }
+                }
+            ]
+        },
+        {
+            "mask": "1101'1RRR AAAA'AAAA",
+            "mnemonic": "DJNZ",
+            "format": "R{R}, PC + 0x{R:02X}",
+            "metadata": [
+                {
+                    "type": "jump",
+                    "data": {
+                        "destination": "offset + 2 + A"
+                    }
+                }
+            ]
+        },
+        {
+            "mask": "0101'0000 AAAA'AAAA",
+            "mnemonic": "JNC",
+            "format": "PC + 0x{A:02X}",
+            "metadata": [
+                {
+                    "type": "jump",
+                    "data": {
+                        "destination": "offset + 2 + A"
+                    }
+                }
+            ]
+        },
+        {
+            "mask": "1101'0000 AAAA'AAAA",
+            "mnemonic": "POP",
+            "format": "IRAM[0x{A:02X}]"
+        },
+        {
+            "mask": "1100'0000 AAAA'AAAA",
+            "mnemonic": "PUSH",
+            "format": "IRAM[0x{A:02X}]"
+        },
+        {
+            "mask": "1101'0100",
+            "mnemonic": "DA",
+            "format": ""
+        },
+        {
+            "mask": "1100'0100",
+            "mnemonic": "SWAP",
+            "format": "A"
+        },
+        {
+            "mask": "1111'0100",
+            "mnemonic": "CPL",
+            "format": "A"
+        },
+        {
+            "mask": "1011'0011",
+            "mnemonic": "CPL",
+            "format": "C"
+        },
+        {
+            "mask": "1011'0010 BBBB'BBBB",
+            "mnemonic": "CPL",
+            "format": "BIT[0x{B:02X}]"
+        },
+        {
+            "mask": "1010'0101",
+            "mnemonic": "INVALID",
+            "format": ""
+        },
+        {
+            "mask": "XXXX'XXXX",
+            "mnemonic": "DB",
+            "format": "#0x{X:02X}",
+            "metadata": [
+                {
+                    "type": "data",
+                    "data": {
+                        "value": "X"
+                    }
+                }
+            ]
+        }
+
+    ]
+}

includes/hex/core.pat

@@ -1,12 +1,12 @@
 #pragma once
 
-#include <hex/impl/imhex_check.pat>
+import hex.impl.imhex_check;
 
 /*!
     Core intrinsic functions to interact with the ImHex Hex Editor
 */
 
-namespace hex::core {
+namespace auto hex::core {
 
     /**
         A type representing a selection in the hex editor
@@ -21,20 +21,30 @@ namespace hex::core {
         @return The current selection
     */
     fn get_selection() {
-        u128 result = builtin::hex::core::get_selection();
+        u128 selection = builtin::hex::core::get_selection();
 
         Selection result;
-        if (result == u128(-1)) {
+        if (selection == u128(-1)) {
             result.valid    = false;
             result.address  = 0x00;
             result.size     = 0x00;
         } else {
             result.valid    = true;
-            result.address  = result >> 64;
+            result.address  = selection >> 64;
-            result.size     = result & u64(-1);
+            result.size     = selection & u64(-1);
         }
 
         return result;
     };
 
-}
+    /**
+        Add a file to the Virtual Filesystem
+        @param path The name of the file
+        @param pattern The pattern associated with the file
+    */
+    fn add_virtual_file(str path, auto pattern)
+    {
+        builtin::hex::core::add_virtual_file(path, pattern);
+    };
+
+}

includes/hex/dec.pat

@@ -1,12 +1,14 @@
 #pragma once
 
-#include <hex/impl/imhex_check.pat>
+import hex.impl.imhex_check;
+
+import std.mem;
 
 /*!
     Library to allow decoding of more complex values
 */
 
-namespace hex::dec {
+namespace auto hex::dec {
 
     /**
         Demangles a mangled name into a human readable name
@@ -17,4 +19,57 @@ namespace hex::dec {
         return builtin::hex::dec::demangle(mangled_name);
     };
 
+
+    /**
+        Decompresses the bytes of a pattern into a section using the zlib algorithm
+        @param pattern The pattern whose bytes should be decompressed
+        @param section The section to decompress the data into
+        @param window_size The window size passed to zlib
+        @return A value representing either the number of bytes decompressed or an error code from zlib
+    */
+    fn zlib_decompress(ref auto pattern, std::mem::Section section, u64 window_size = 0) {
+        return builtin::hex::dec::zlib_decompress(pattern, section, window_size);
+    };
+
+    /**
+        Decompresses the bytes of a pattern into a section using the bzip algorithm
+        @param pattern The pattern whose bytes should be decompressed
+        @param section The section to decompress the data into
+        @return true if successful, false otherwise
+    */
+    fn bzip_decompress(ref auto pattern, std::mem::Section section) {
+        return builtin::hex::dec::bzip_decompress(pattern, section);
+    };
+
+    /**
+        Decompresses the bytes of a pattern into a section using the LZMA algorithm
+        @param pattern The pattern whose bytes should be decompressed
+        @param section The section to decompress the data into
+        @return true if successful, false otherwise
+    */
+    fn lzma_decompress(ref auto pattern, std::mem::Section section) {
+        return builtin::hex::dec::lzma_decompress(pattern, section);
+    };
+
+    /**
+        Decompresses the bytes of a pattern into a section using the zstd algorithm
+        @param pattern The pattern whose bytes should be decompressed
+        @param section The section to decompress the data into
+        @return true if successful, false otherwise
+    */
+    fn zstd_decompress(ref auto pattern, std::mem::Section section) {
+        return builtin::hex::dec::zstd_decompress(pattern, section);
+    };
+
+    /**
+        Decompresses the bytes of a pattern into a section using the lz4 algorithm
+        @param pattern The pattern whose bytes should be decompressed
+        @param section The section to decompress the data into
+        @param frame Whether the data is framed or not
+        @return true if successful, false otherwise
+    */
+    fn lz4_decompress(ref auto pattern, std::mem::Section section, bool frame = true) {
+        return builtin::hex::dec::lz4_decompress(pattern, section, frame);
+    };
+
 }

includes/hex/http.pat

@@ -1,12 +1,12 @@
 #pragma once
 
-#include <hex/impl/imhex_check.pat>
+import hex.impl.imhex_check;
 
 /*!
     Library to do HTTP requests
 */
 
-namespace hex::http {
+namespace auto hex::http {
 
     /**
         Performs a HTTP GET request to the given URL and returns the response body

includes/hex/provider.pat

@@ -1,17 +1,17 @@
 #pragma once
 
-#include <hex/impl/imhex_check.pat>
+import hex.impl.imhex_check;
 
 /*!
     Library to interact with the currently loaded provider.
 */
 
-namespace hex::prv {
+namespace auto hex::prv {
-    
+
-    
+
     /**
         Queries information from the currently loaded provider. The kind of information that's available depends on the provider that's loaded
-        
+
         > **Available information**
         > - File Provider
         >   - `file_path() -> str`
@@ -32,12 +32,12 @@ namespace hex::prv {
         >   - `region_size(regionName) -> u64`
         >   - `process_id() -> u32`
         >   - `process_name() -> str`
-        
+
         @param category Information category
         @param argument Extra argument to pass along
     */
     fn get_information(str category, str argument = "") {
         return builtin::hex::prv::get_information(category, argument);
     };
-    
+
 }

includes/hex/type/encstr.pat

@@ -0,0 +1,28 @@
+#pragma once
+
+import hex.impl.imhex_check;
+
+/*!
+    Types to work with custom encoded strings using Thiny encoding definitions
+*/
+
+namespace auto hex::type {
+    
+    /**
+        A string that was encoded using a custom encoding
+        @tparam Data Pattern whose bytes are used in the decoding process
+        @tparam EncodingDefinition A string containing a Thingy encoding definition as used by ImHex's custom encoding feature
+    */
+    struct EncodedString<auto Data, auto EncodingDefinition> {
+        builtin::hex::dec::EncodedString<Data, EncodingDefinition> string;
+    } [[sealed, format("hex::type::impl::format_encoded_string")]];
+    
+    namespace impl {
+
+        fn format_encoded_string(ref auto string) {
+            return string.string;
+        };
+    }
+    
+}
+

includes/hex/type/instruction.pat

@@ -0,0 +1,143 @@
+#pragma once
+
+import hex.impl.imhex_check;
+
+/*!
+    Types to work with machine code
+*/
+
+namespace auto hex::type {
+
+    /**
+        A machine code instruction which will get disassembled
+        @tparam DisassemblerSetting A string containing the config for the disassembler in the form of "architecture; setting1, setting2, no-setting3"
+        @tparam SyntaxType Syntax used in the disassembly. Possible values are "intel", "at&t", "masm" and "motorola"
+        @tparam ImageBaseAddress Start address of the instruction region in the data
+        @tparam ImageLoadAddress Address where the instructions will be loaded into memory
+
+        Possible Values for DisassemblerSetting:
+        - Architecture, all may be suffixed with le or be to specify endianess (e.g armbe or mipsle)
+            - arm
+            - thumb
+            - aarch64
+            - arm64
+            - mips
+            - x86
+            - x86_64
+            - x64
+            - ppc
+            - powerpc
+            - sparc
+            - sysz
+            - xcore
+            - m68k
+            - m680x
+            - tms320c64x
+            - evm
+            - wasm
+            - riscv
+            - mos65xx
+            - bpf
+            - sh
+            - tricore
+
+        - Settings, not all settings make sense for each architecture. Prefixing settings with no- will remove them instead
+            - 16bit
+            - 32bit
+            - 64bit
+            - cortex-m
+            - armv8
+            - micromips
+            - mips2
+            - mips3
+            - mips32r6
+            - sparcv9
+            - qpx
+            - spe
+            - ps
+            - 68000
+            - 68010
+            - 68020
+            - 68030
+            - 68040
+            - 68060
+            - 6301
+            - 6309
+            - 6800
+            - 6801
+            - 6805
+            - 6808
+            - 6809
+            - 6811
+            - cpu12
+            - hcs08
+            - bpfe
+            - rv32g
+            - rv64g
+            - riscvc
+            - 6502
+            - 65c02
+            - w65c02
+            - 65816
+            - long-m
+            - long-x
+            - sh2
+            - sh2a
+            - sh3
+            - sh4
+            - sh4a
+            - shfpu
+            - shdsp
+            - 1.1
+            - 1.2
+            - 1.3
+            - 1.3.1
+            - 1.6
+            - 1.6.1
+            - 1.6.2
+    */
+    struct Instruction<auto DisassemblerSetting, auto SyntaxType, auto ImageBaseAddress, auto ImageLoadAddress> {
+        builtin::hex::dec::Instruction<DisassemblerSetting, SyntaxType, ImageBaseAddress, ImageLoadAddress> instruction;
+    } [[sealed, format("hex::type::impl::format_instruction")]];
+
+    /**
+        A machine code instruction which will get disassembled using Intel syntax
+        @tparam DisassemblerSetting A string containing the config for the disassembler in the form of "architecture; setting1, setting2, no-setting3"
+        @tparam ImageBaseAddress Start address of the instruction region in the data
+        @tparam ImageLoadAddress Address where the instructions will be loaded into memory
+    */
+    using InstructionIntel<auto DisassemblerSetting, auto ImageBaseAddress, auto ImageLoadAddress> = Instruction<DisassemblerSetting, "intel", ImageBaseAddress, ImageLoadAddress>;
+    
+    /**
+        A machine code instruction which will get disassembled using AT&T syntax
+        @tparam DisassemblerSetting A string containing the config for the disassembler in the form of "architecture; setting1, setting2, no-setting3"
+        @tparam ImageBaseAddress Start address of the instruction region in the data
+        @tparam ImageLoadAddress Address where the instructions will be loaded into memory
+    */
+    using InstructionATNT<auto DisassemblerSetting, auto ImageBaseAddress, auto ImageLoadAddress> = Instruction<DisassemblerSetting, "at&t", ImageBaseAddress, ImageLoadAddress>;
+    
+    /**
+        A machine code instruction which will get disassembled using MASM syntax
+        @tparam DisassemblerSetting A string containing the config for the disassembler in the form of "architecture; setting1, setting2, no-setting3"
+        @tparam ImageBaseAddress Start address of the instruction region in the data
+        @tparam ImageLoadAddress Address where the instructions will be loaded into memory
+    */    
+    using InstructionMASM<auto DisassemblerSetting, auto ImageBaseAddress, auto ImageLoadAddress> = Instruction<DisassemblerSetting, "masm", ImageBaseAddress, ImageLoadAddress>;
+    
+    /**
+        A machine code instruction which will get disassembled using Motorola syntax
+        @tparam DisassemblerSetting A string containing the config for the disassembler in the form of "architecture; setting1, setting2, no-setting3"
+        @tparam ImageBaseAddress Start address of the instruction region in the data
+        @tparam ImageLoadAddress Address where the instructions will be loaded into memory
+    */
+    using InstructionMotorola<auto DisassemblerSetting, auto ImageBaseAddress, auto ImageLoadAddress> = Instruction<DisassemblerSetting, "motorola", ImageBaseAddress, ImageLoadAddress>;
+
+    namespace impl {
+
+        fn format_instruction(ref auto instruction) {
+            return instruction.instruction;
+        };
+    }
+
+}
+

includes/hex/type/json.pat

@@ -0,0 +1,66 @@
+#pragma once
+
+import hex.impl.imhex_check;
+
+/*!
+    Types to decode JSON and JSON-like file formats into a pattern tree
+*/
+
+namespace auto hex::type {
+    
+    /**
+        Type representing a JSON string
+        @tparam Size size of the string
+    */
+    struct Json<auto Size> {
+        char __data[Size] [[hidden, no_unique_address]];
+        builtin::hex::dec::Json<__data> json [[merge]];
+    };
+
+    /**
+        Type representing Bson data 
+        @tparam Size size of the data
+    */
+    struct Bson<auto Size> {
+        u8 __data[Size] [[hidden, no_unique_address]];
+        builtin::hex::dec::Bson<__data> bson [[merge]];
+    };
+
+    /**
+        Type representing Cbor data 
+        @tparam Size size of the data
+    */
+    struct Cbor<auto Size> {
+        u8 __data[Size] [[hidden, no_unique_address]];
+        builtin::hex::dec::Cbor<__data> cbor [[merge]];
+    };
+
+    /**
+        Type representing Bjdata data 
+        @tparam Size size of the data
+    */
+    struct Bjdata<auto Size> {
+        u8 __data[Size] [[hidden, no_unique_address]];
+        builtin::hex::dec::Bjdata<__data> bjdata [[merge]];
+    };
+
+    /**
+        Type representing Msgpack data 
+        @tparam Size size of the data
+    */
+    struct Msgpack<auto Size> {
+        u8 __data[Size] [[hidden, no_unique_address]];
+        builtin::hex::dec::Msgpack<__data> msgpack [[merge]];
+    };
+
+    /**
+        Type representing Ubjson data 
+        @tparam Size size of the data
+    */
+    struct Ubjson<auto Size> {
+        u8 __data[Size] [[hidden, no_unique_address]];
+        builtin::hex::dec::Ubjson<__data> ubjson [[merge]];
+    };
+    
+}
+

includes/hex/type/mangled.pat

@@ -1,30 +1,30 @@
 #pragma once
 
-#include <std/io.pat>
+import std.io;
-#include <std/mem.pat>
+import std.mem;
 
-#include <hex/impl/imhex_check.pat>
+import hex.impl.imhex_check;
-#include <hex/dec.pat>
+import hex.dec;
 
 /*!
     Types to automatically decode mangled names
 */
 
-namespace hex::type {
+namespace auto hex::type {
-	
+    
     /**
         A mangled name string that gets demangled when displayed
     */
     struct MangledName {
         char value[];
     } [[sealed, format("hex::type::impl::format_mangled_name")]];
-	
+    
     namespace impl {
 
         fn format_mangled_name(ref MangledName name) {
             return hex::dec::demangle(name.value);
         };
     }
-	
+    
 }
 

includes/std/array.pat

@@ -1,19 +1,68 @@
 #pragma once
 
+import std.sys;
+import std.core;
+
 /*!
     The array library contains a helper type to make it easier to create multi-dimensional arrays
     and pass arrays to functions as parameters.
+
+    ## Multi-dimensional arrays
+
+    The following example shows how to use multi-dimensional arrays with structs.
+
+    ```rust
+    import std.array;
+
+    struct File {
+        u8 width, height;
+        std::Array<std::Array<u8, parent.width>, height> cells;
+    };
+
+    File file @ 0x00;
+    ```
+
 */
 
-namespace std {
+namespace auto std {
 
     /**
         Simple one dimensional array wrapper
         @tparam T The array types
-        @tparam Size Size of the array
+        @tparam Size Number of entries in the array
     */
     struct Array<T, auto Size> {
         T data[Size] [[inline]];
+    } [[format("std::impl::format_array")]];
+
+    /**
+        Simple array wrapper for an array with a size in bytes
+        @tparam T The array types
+        @tparam NumBytes Number of bytes the array contains
+    */
+    struct ByteSizedArray<T, auto NumBytes> {
+        u64 startAddress = $;
+        T array[while($ - startAddress < NumBytes)] [[inline]];
+
+        std::assert($ - startAddress == NumBytes, "Not enough bytes available to fit a whole number of types");
+    } [[format("std::impl::format_array")]];
+
+
+    /**
+        An interface type for getting the index of the currently processed element in an array. This is a nice wrapper around `std::core::array_index()`
+
+        To use it, inherit from it and use the `this.index` field to get the index of the current element
+    */
+    struct IIndexed {
+        const u64 index = std::core::array_index();
     };
 
+    namespace impl {
+
+        fn format_array(ref auto array) {
+            return "[ ... ]";
+        };
+
+    }
+
 }

includes/std/attrs.pat

@@ -0,0 +1,70 @@
+import std.io;
+import std.core;
+
+/*!
+    The attributes library contains a set of attributes that can be used to annotate types with certain properties.
+    To use an attribute, simply make your custom type inherit from the attribute type you want to use.
+
+    For example, to make a type hidden, you can use the `Hidden` attribute like this:
+
+    ```rust
+    struct MyType : std::attr::Hidden {
+        // ...
+    };
+    ```
+*/
+
+namespace auto std::attr {
+
+    /**
+        Attribute that marks a type as a literal type.
+        This means the type behaves like a built-in type in the sense that it doesn't show its internal state and its display value is determined by a format function.
+        It can also be transformed into a different built-in literal when used in an expression.
+        @tparam FormatFunction The format function to use. The return value of this function is used to display the value of the literal and also determines the value returned when the literal is used in an expression.
+    */
+    struct Literal<auto FormatFunction> { }
+    [[sealed, format_read(FormatFunction), transform(FormatFunction)]];
+
+    /**
+        Attribute that changes the name of the variable created from a type.
+        @tparam Name The name of the variable created
+    */
+    struct Named<auto Name> { }
+    [[name(Name)]];
+
+    /**
+        Attribute that adds a comment to the variable created from a type.
+        @tparam Comment The comment to add
+    */
+    struct Commented<auto Comment> {}
+    [[comment(Comment)]];
+
+    /**
+        Attribute that marks a type as hidden.
+        This means variables of this type are not displayed in the UI.
+    */
+    struct Hidden {}
+    [[hidden]];
+
+    /**
+        Attribute that marks a type as hidden and also hides it from the highlighter.
+        This means variables of this type are don't display any highlighting in the UI but are still visible.
+    */
+    struct HighlightHidden {}
+    [[highlight_hidden]];
+
+    /**
+        Attribute that marks a type as inline.
+        Creating a variable of this type will not create a new layer but instead dump the contents of the type directly into the current layer.
+    */
+    struct Inlined {}
+    [[inline]];
+
+    /**
+        Attribute that marks a type as sealed.
+        Sealed types don't display their internal state in the UI.
+    */
+    struct Sealed {}
+    [[sealed]];
+
+}

includes/std/bit.pat

@@ -1,63 +1,67 @@
 #pragma once
 
-#include <std/limits.pat>
+import std.limits;
 
 /*!
-	This library contains various helper functions for common bit operations.
+    This library contains various helper functions for common bit operations.
 */
 
-namespace std::bit {
+namespace auto std::bit {
 
-	/**
+    /**
-		Calculates the number of 1 bits in a given number
+        Calculates the number of 1 bits in a given number
-		@param x The number
+        @param x The number
-		@return The number of bits set to 1 in `x`
+        @return The number of bits set to 1 in `x`
-	*/
+    */
-	fn popcount(u128 x) {
+    fn popcount(u128 x) {
-		x = (x & (std::limits::u128_max() /  3)) + ((x >> 1) & (std::limits::u128_max() /  3));
+        const u128 a = 0x55555555555555555555555555555555;
-		x = (x & (std::limits::u128_max() /  5)) + ((x >> 2) & (std::limits::u128_max() /  5));
+        const u128 b = 0x33333333333333333333333333333333;
-		x = (x & (std::limits::u128_max() / 17)) + ((x >> 4) & (std::limits::u128_max() / 17));
+        const u128 c = 0x0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F;
-		
-		return x % 0xFF;
-	};
 
-	/**
+        x = (x & a) + ((x >> 1) & a);
-		Checks if only a single bit is set to 1 in a given number
+        x = (x & b) + ((x >> 2) & b);
-		@param x The number
+        x = (x & c) + ((x >> 4) & c);
-		@return True if there's a single bit set to 1 in `x`, false otherwise
-	*/
-	fn has_single_bit(u128 x) {
-		return x != 0 && (x & (x - 1)) == 0;
-	};
-	
-	/**
-		Rounds the given number up to the next bigger power of two
-		@param x The number
-		@return Next bigger power of two that can fit `x`
-	*/
-	fn bit_ceil(u128 x) {		
-		if (x == 0) return 0;
-		
-		u8 i;
-		while ((1 << i) < x)
-			i = i + 1;
-		
-		return 1 << i;
-	};
 
-	/**
+        return x % 0xFF;
-		Rounds the given number down to the next bigger power of two
+    };
-		@param x The number
+
-		@return Next smaller power of two
+    /**
-	*/
+        Checks if only a single bit is set to 1 in a given number
-	fn bit_floor(u128 x) {
+        @param x The number
-		if (x == 0) return 0;
+        @return True if there's a single bit set to 1 in `x`, false otherwise
-		
+    */
-		u8 i;
+    fn has_single_bit(u128 x) {
-		while ((x >> i) > 0)
+        return x != 0 && (x & (x - 1)) == 0;
-			i = i + 1;
+    };
-		
+
-		return 1 << (i - 1);
+    /**
-	};
+        Rounds the given number up to the next bigger power of two
+        @param x The number
+        @return Next bigger power of two that can fit `x`
+    */
+    fn bit_ceil(u128 x) {
+        if (x == 0) return 0;
+
+        u8 i;
+        while ((1 << i) < x)
+            i = i + 1;
+
+        return 1 << i;
+    };
+
+    /**
+        Rounds the given number down to the next bigger power of two
+        @param x The number
+        @return Next smaller power of two
+    */
+    fn bit_floor(u128 x) {
+        if (x == 0) return 0;
+
+        u8 i;
+        while ((x >> i) > 0)
+            i = i + 1;
+
+        return 1 << (i - 1);
+    };
 
 }

includes/std/core.pat

@@ -1,13 +1,13 @@
 #pragma once
 
-#include <std/mem.pat>
+import std.mem;
 
 /*!
     The core library contains intrinsics and "compiler magic" functions that
     get extra help from the runtime to fulfill their purpose.
 */
 
-namespace std::core {
+namespace auto std::core {
 
     /**
         The layout order of each field after byte-endianness has been handled.
@@ -38,27 +38,35 @@ namespace std::core {
     };
 
     /**
-        Returns the first parameter of the attribute of a pattern if it has one
+        Returns the nth parameter of the attribute of a pattern if it has one
         @param pattern The pattern to check
         @param attribute The attribute's name to query
+        @param [index] The parameter index of the attribute to return. Defaults to 0
+    */
+    fn get_attribute_argument(ref auto pattern, str attribute, u32 index = 0) {
+        return builtin::std::core::get_attribute_argument(pattern, attribute, index);
+    };
+
+    /**
+        @warning Removed in 1.27.0
     */
     fn get_attribute_value(ref auto pattern, str attribute) {
-        return builtin::std::core::get_attribute_value(pattern, attribute);
+        builtin::std::error("`std::core::get_attribute_value(pattern, attribute)` has been removed.\nUse `std::core::get_attribute_argument(pattern, attribute, [index])` instead.");
     };
 
 
     /**
-        Sets the current default endianess.
+        Sets the current default endianness.
-        Any patterns created following this attribute will be created using the set endianess.
+        Any patterns created following this attribute will be created using the set endianness.
-        @param endian The new default endianess
+        @param endian The new default endianness
     */
     fn set_endian(std::mem::Endian endian) {
         builtin::std::core::set_endian(u32(endian));
     };
 
     /**
-        Gets the current default endianess.
+        Gets the current default endianness.
-        @return The currently set default endianess
+        @return The currently set default endianness
     */
     fn get_endian() {
         return builtin::std::core::get_endian();
@@ -146,4 +154,39 @@ namespace std::core {
     fn set_display_name(ref auto pattern, str name) {
         builtin::std::core::set_display_name(pattern, name);
     }; 
+
+
+    /**
+        Changes the comment attached to a pattern
+        @param pattern The pattern to modify
+        @param comment The new comment of the pattern
+    */
+    fn set_pattern_comment(ref auto pattern, str comment) {
+        builtin::std::core::set_pattern_comment(pattern, comment);
+    }; 
+
+    /**
+        Executes the function with the given name, passing in all given arguments
+        @param function_name The namespace-prefixed name of the function
+        @param args Arguments to pass to the function
+    */
+    fn execute_function(str function_name, auto ... args) {
+        builtin::std::core::execute_function(function_name, args);
+    };
+
+    /**
+        Sets the pattern color palette for all future created patterns
+        @param args RGBA8 colors as 32 bit integers (0xAABBGGRR)
+    */
+    fn set_pattern_palette_colors(auto ... colors) {
+        builtin::std::core::set_pattern_palette_colors(colors);
+    };
+
+    /**
+        Resets the current pattern palette progress back to zero.
+        This can be useful to force all instances of a type to have the same coloring for its members
+    */
+    fn reset_pattern_palette() {
+        builtin::std::core::reset_pattern_palette();
+    };
 }

includes/std/ctype.pat

@@ -5,7 +5,7 @@
     of ASCII characters.
 */
 
-namespace std::ctype {
+namespace auto std::ctype {
 
     /**
         Checks if the given character `c` is a digit between '0' and '9'
@@ -85,7 +85,7 @@ namespace std::ctype {
         @return True if `c` is part of this range, false otherwise
     */
     fn isprint(char c) {
-        return c >= '0' && c <= '~';
+        return c >= ' ' && c <= '~';
     };
 
     /**

includes/std/file.pat

@@ -1,112 +1,120 @@
 #pragma once
 
 /*!
-	The File library allows reading and writing from/to external files using 
+    The File library allows reading and writing from/to external files using
-	a C-like File IO API.
+    a C-like File IO API.
 
-	**These functions are considered dangerous and require the user to manually permit them**
+    **These functions are considered dangerous and require the user to manually permit them**
 */
 
-namespace std::file {
+namespace auto std::file {
 
-	/**
+    /**
         A handle representing a file that has been opened
     */
-	using Handle = s32;
+    using Handle = s32;
-	
+
-	/**
+    /**
         The mode to open a file in.
-		Read opens the file in read-only mode
+        Read opens the file in read-only mode
-		Write opens the file in read and write mode
+        Write opens the file in read and write mode
-		Create creates a new file if it doesn't exist and overwrites an existing file
+        Create creates a new file if it doesn't exist and overwrites an existing file
     */
-	enum Mode : u8 {
+    enum Mode : u8 {
-		Read = 1,
+        Read = 1,
-		Write = 2,
+        Write = 2,
-		Create = 3
+        Create = 3
-	};
+    };
 
 
-	/**
+    /**
         Opens a file
-		@param path The path to the file to open
+        @param path The path to the file to open
-		@param mode File open mode
+        @param mode File open mode
-		@return Handle to the newly opened file
+        @return Handle to the newly opened file
     */
-	fn open(str path, Mode mode) {
+    fn open(str path, Mode mode) {
-		return builtin::std::file::open(path, u32(mode));
+        return builtin::std::file::open(path, u32(mode));
-	};
+    };
 
-	/**
+    /**
         Closes a file handle that has been opened previously
-		@param handle The handle to close
+        @param handle The handle to close
     */
-	fn close(Handle handle) {
+    fn close(Handle handle) {
-		builtin::std::file::close(handle);
+        builtin::std::file::close(handle);
-	};
+    };
 
-	
+
-	/**
+    /**
         Reads the content of a file into a string
-		@param handle The file handle to read from
+        @param handle The file handle to read from
-		@param size Number of bytes to read
+        @param size Number of bytes to read
-		@return String containing the read data
+        @return String containing the read data
     */
-	fn read(Handle handle, u64 size) {
+    fn read(Handle handle, u64 size) {
-		return builtin::std::file::read(handle, size);
+        return builtin::std::file::read(handle, size);
-	};
+    };
 
-	/**
+    /**
         Writes the content of a string into a file
-		@param handle The file handle to write to
+        @param handle The file handle to write to
-		@param data String or Pattern to write to the file
+        @param data String or Pattern to write to the file
     */
-	fn write(Handle handle, auto data) {
+    fn write(Handle handle, auto data) {
-		builtin::std::file::write(handle, data);
+        builtin::std::file::write(handle, data);
-	};
+    };
 
-	/**
+    /**
         Sets the current cursor position in the given file handle
-		@param handle The file handle to set the cursor position in
+        @param handle The file handle to set the cursor position in
-		@param offset The offset to move the cursor to
+        @param offset The offset to move the cursor to
     */
-	fn seek(Handle handle, u64 offset) {
+    fn seek(Handle handle, u64 offset) {
-		builtin::std::file::seek(handle, offset);
+        builtin::std::file::seek(handle, offset);
-	};
+    };
 
 
-	/**
+    /**
-		Queries the size of a file
+        Queries the size of a file
-		@param handle The handle of the file to get the size of
+        @param handle The handle of the file to get the size of
-		@return The file's size
+        @return The file's size
-	*/
+    */
-	fn size(Handle handle) {
+    fn size(Handle handle) {
-		return builtin::std::file::size(handle);
+        return builtin::std::file::size(handle);
-	};
+    };
 
-	/**
+    /**
-		Resizes a file 
+        Resizes a file
-		@param handle The handle of the file to resize
+        @param handle The handle of the file to resize
-	*/
+    */
-	fn resize(Handle handle, u64 size) {
+    fn resize(Handle handle, u64 size) {
-		builtin::std::file::resize(handle, size);
+        builtin::std::file::resize(handle, size);
-	};
+    };
 
-	/** 
+    /**
-		Flushes changes made to a file to disk
+        Flushes changes made to a file to disk
-		@param handle The handle of the file to flush
+        @param handle The handle of the file to flush
-	*/
+    */
-	fn flush(Handle handle) {
+    fn flush(Handle handle) {
-		builtin::std::file::remove(handle);
+        builtin::std::file::flush(handle);
-	};
+    };
 
 
-	/**
+    /**
-		Deletes a file from disk. This will also automatically close this file
+        Deletes a file from disk. This will also automatically close this file
-		@param handle The handle of the file to delete
+        @param handle The handle of the file to delete
-	*/
+    */
-	fn remove(Handle handle) {
+    fn remove(Handle handle) {
-		builtin::std::file::remove(handle);
+        builtin::std::file::remove(handle);
-	};
+    };
+
+    /**
+        Create all directories for the provided path
+        @param path The path for which all directories should be created
+    */
+    fn create_directories(str path) {
+        builtin::std::file::create_directories(path);
+    };
 
 }

includes/std/fxpt.pat

@@ -1,89 +1,89 @@
 #pragma once
 
 /*!
-	Library for doing arithmetic with fixed point numbers and converting them from/to floating point numbers.
+    Library for doing arithmetic with fixed point numbers and converting them from/to floating point numbers.
 */
 
-namespace std::fxpt {
+namespace auto std::fxpt {
 
-	/**
+    /**
-		A fixed point value
+        A fixed point value
-	*/
+    */
-	using fixed = s128;
+    using fixed = s128;
 
-	/**
+    /**
-		Converts a fixed point value into a floating point value
+        Converts a fixed point value into a floating point value
-		@param fxt The fixed point value to convert
+        @param fxt The fixed point value to convert
-		@param precision The bits of precision the new value should have
+        @param precision The bits of precision the new value should have
-		@return The floating point representation of fxt
+        @return The floating point representation of fxt
-	*/
+    */
-	fn to_float(fixed fxt, u32 precision) {
+    fn to_float(fixed fxt, u32 precision) {
-		return double(fxt) / double((1 << precision));
+        return double(fxt) / double((1 << precision));
-	};
+    };
-	
-	/**
-		Converts a floating point value into a fixed point value
-		@param flt The floating point value to convert
-		@param precision The bits of precision the new value should have
-		@return The fixed point representation of flt
-	*/
-	fn to_fixed(double flt, u32 precision) {
-		return s128((flt * (1 << precision)));
-	};
 
-	/**
+    /**
-		Changes the number of bits used to represent the decimal part of the given fixed point number
+        Converts a floating point value into a fixed point value
-		@param value The fixed point value to convert
+        @param flt The floating point value to convert
-		@param start_precision The current number of bits used
+        @param precision The bits of precision the new value should have
-		@param end_precision The new number of bits used
+        @return The fixed point representation of flt
-		@return `value` as a new fixed point number with `end_precision` bits of precision
+    */
-	*/
+    fn to_fixed(double flt, u32 precision) {
-	fn change_precision(fixed value, u32 start_precision, u32 end_precision) {
+        return s128((flt * (1 << precision)));
-		return std::fxpt::to_fixed(std::fxpt::to_float(value, start_precision), end_precision);
+    };
-	};
+
-	
+    /**
-	/**
+        Changes the number of bits used to represent the decimal part of the given fixed point number
-		Adds two fixed point numbers with a given precision together
+        @param value The fixed point value to convert
-		@param a First fixed point number
+        @param start_precision The current number of bits used
-		@param b Second fixed point number
+        @param end_precision The new number of bits used
-		@param precision The precision of `a` and `b`
+        @return `value` as a new fixed point number with `end_precision` bits of precision
-		@return Result of the addition of `a` and `b`
+    */
-	*/
+    fn change_precision(fixed value, u32 start_precision, u32 end_precision) {
-	fn add(fixed a, fixed b, u32 precision) {
+        return std::fxpt::to_fixed(std::fxpt::to_float(value, start_precision), end_precision);
-		return a + b;
+    };
-	};
+
-	
+    /**
-	/**
+        Adds two fixed point numbers with a given precision together
-		Subtracts two fixed point numbers with a given precision together
+        @param a First fixed point number
-		@param a First fixed point number
+        @param b Second fixed point number
-		@param b Second fixed point number
+        @param precision The precision of `a` and `b`
-		@param precision The precision of `a` and `b`
+        @return Result of the addition of `a` and `b`
-		@return Result of the subtraction of `a` and `b`
+    */
-	*/
+    fn add(fixed a, fixed b, u32 precision) {
-	fn subtract(fixed a, fixed b, u32 precision) {
+        return a + b;
-		return a - b;
+    };
-	};
+
-	
+    /**
-	/**
+        Subtracts two fixed point numbers with a given precision together
-		Multiplies two fixed point numbers with a given precision together
+        @param a First fixed point number
-		@param a First fixed point number
+        @param b Second fixed point number
-		@param b Second fixed point number
+        @param precision The precision of `a` and `b`
-		@param precision The precision of `a` and `b`
+        @return Result of the subtraction of `a` and `b`
-		@return Result of the multiplication of `a` and `b`
+    */
-	*/
+    fn subtract(fixed a, fixed b, u32 precision) {
-	fn multiply(fixed a, fixed b, u32 precision) {
+        return a - b;
-		return (a * b) / (1 << precision);
+    };
-	};
+
-	
+    /**
-	/**
+        Multiplies two fixed point numbers with a given precision together
-		Divides two fixed point numbers with a given precision together
+        @param a First fixed point number
-		@param a First fixed point number
+        @param b Second fixed point number
-		@param b Second fixed point number
+        @param precision The precision of `a` and `b`
-		@param precision The precision of `a` and `b`
+        @return Result of the multiplication of `a` and `b`
-		@return Result of the division of `a` and `b`
+    */
-	*/
+    fn multiply(fixed a, fixed b, u32 precision) {
-	fn divide(fixed a, fixed b, u32 precision) {
+        return (a * b) / (1 << precision);
-		return (a << precision) / b;
+    };
-	};
+
+    /**
+        Divides two fixed point numbers with a given precision together
+        @param a First fixed point number
+        @param b Second fixed point number
+        @param precision The precision of `a` and `b`
+        @return Result of the division of `a` and `b`
+    */
+    fn divide(fixed a, fixed b, u32 precision) {
+        return (a << precision) / b;
+    };
 
 }

includes/std/hash.pat

@@ -4,20 +4,62 @@
     The hash library contains various data hash functions
 */
 
-namespace std::hash {
+namespace auto std::hash {
+
+    /**
+        Calculates the CRC8 hash of the bytes inside of a given pattern
+        @param pattern The pattern to calculate the CRC8 hash of
+        @param init The CRC8 init value
+        @param poly The CRC8 polynomial
+        @param xorout The CRC8 XOR-Out value
+        @param reflect_in Whether or not the input bytes should be reflected
+        @param reflect_out Whether or not the output should be reflected
+        @return Calculated CRC8 hash
+    */
+    fn crc8(ref auto pattern, u8 init, u8 poly, u8 xorout, bool reflect_in, bool reflect_out) {
+        return builtin::std::hash::crc8(pattern, init, poly, xorout, reflect_in, reflect_out);
+    };
+
+    /**
+        Calculates the CRC16 hash of the bytes inside of a given pattern
+        @param pattern The pattern to calculate the CRC16 hash of
+        @param init The CRC16 init value
+        @param poly The CRC16 polynomial
+        @param xorout The CRC16 XOR-Out value
+        @param reflect_in Whether or not the input bytes should be reflected
+        @param reflect_out Whether or not the output should be reflected
+        @return Calculated CRC16 hash
+    */
+    fn crc16(ref auto pattern, u16 init, u16 poly, u16 xorout, bool reflect_in, bool reflect_out) {
+        return builtin::std::hash::crc16(pattern, init, poly, xorout, reflect_in, reflect_out);
+    };
 
     /**
         Calculates the CRC32 hash of the bytes inside of a given pattern
-        @param pattern The pattern to calculate the crc32 hash of
+        @param pattern The pattern to calculate the CRC32 hash of
         @param init The CRC32 init value
         @param poly The CRC32 polynomial
         @param xorout The CRC32 XOR-Out value
         @param reflect_in Whether or not the input bytes should be reflected
         @param reflect_out Whether or not the output should be reflected
-        @return Calculated CRC32 hash 
+        @return Calculated CRC32 hash
     */
     fn crc32(ref auto pattern, u32 init, u32 poly, u32 xorout, bool reflect_in, bool reflect_out) {
         return builtin::std::hash::crc32(pattern, init, poly, xorout, reflect_in, reflect_out);
     };
 
+    /**
+        Calculates the CRC64 hash of the bytes inside of a given pattern
+        @param pattern The pattern to calculate the CRC64 hash of
+        @param init The CRC64 init value
+        @param poly The CRC64 polynomial
+        @param xorout The CRC64 XOR-Out value
+        @param reflect_in Whether or not the input bytes should be reflected
+        @param reflect_out Whether or not the output should be reflected
+        @return Calculated CRC64 hash
+    */
+    fn crc64(ref auto pattern, u64 init, u64 poly, u64 xorout, bool reflect_in, bool reflect_out) {
+        return builtin::std::hash::crc64(pattern, init, poly, xorout, reflect_in, reflect_out);
+    };
+
 }

includes/std/io.pat

@@ -4,26 +4,26 @@
     The IO library allows formatting strings and outputting text to the console
 */
 
-namespace std {
+namespace auto std {
 
     /**
         Formats the given arguments using the format string and prints the result to the console
         This function uses the C++20 `std::format` or libfmt's `fmt::format` syntax.
-        @param fmt Format string
+        @param fmt Format string or any other value that can be converted to a string
         @param args Values to use in the formatting
     */
-    fn print(str fmt, auto ... args) {
+    fn print(auto fmt, auto ... args) {
         builtin::std::print(fmt, args);
     };
 
     /**
         Formats the given arguments using the format string and returns the result as a string
         This function uses the C++20 `std::format` or libfmt's `fmt::format` syntax.
-        @param fmt Format string
+        @param fmt Format string or any other value that can be converted to a string
         @param args Values to use in the formatting
         @return The formatted string
     */
-    fn format(str fmt, auto ... args) {
+    fn format(auto fmt, auto ... args) {
         return builtin::std::format(fmt, args);
     };
 

includes/std/limits.pat

@@ -1,169 +1,169 @@
 #pragma once
 
 /*!
-	Library to calculate the minimum and maximum values that fit into a given data type
+    Library to calculate the minimum and maximum values that fit into a given data type
 */
 
-namespace std::limits {
+namespace auto std::limits {
-	
-	/**
-		Returns the minimum value that can be stored in a `u8`.
-		@return Minimum value
-	*/
-	fn u8_min() {
-		return u8(0);
-	};
-	
-	/**
-		Returns the maximum value that can be stored in a `u8`.
-		@return Maximum value
-	*/
-	fn u8_max() {
-		return u8(-1);
-	};
 
-	/**
+    /**
-		Returns the minimum value that can be stored in a `s8`.
+        Returns the minimum value that can be stored in a `u8`.
-		@return Minimum value
+        @return Minimum value
-	*/
+    */
+    fn u8_min() {
+        return u8(0);
+    };
+
+    /**
+        Returns the maximum value that can be stored in a `u8`.
+        @return Maximum value
+    */
+    fn u8_max() {
+        return u8(-1);
+    };
+
+    /**
+        Returns the minimum value that can be stored in a `s8`.
+        @return Minimum value
+    */
     fn s8_min() {
-		return -s8((std::limits::u8_max() / 2)) - 1;
+        return -s8((std::limits::u8_max() / 2)) - 1;
-	};
+    };
-	
+
-	/**
+    /**
-		Returns the maximum value that can be stored in a `s8`.
+        Returns the maximum value that can be stored in a `s8`.
-		@return Maximum value
+        @return Maximum value
-	*/
+    */
-	fn s8_max() {
+    fn s8_max() {
-		return s8((std::limits::u8_max() / 2));
+        return s8((std::limits::u8_max() / 2));
-	};
+    };
+
+    /**
+        Returns the minimum value that can be stored in a `u16`.
+        @return Minimum value
+    */
+    fn u16_min() {
+        return u16(0);
+    };
+
+    /**
+        Returns the maximum value that can be stored in a `u16`.
+        @return Maximum value
+    */
+    fn u16_max() {
+        return u16(-1);
+    };
+
+    /**
+        Returns the minimum value that can be stored in a `s16`.
+        @return Minimum value
+    */
+    fn s16_min() {
+        return -s16((std::limits::u16_max() / 2)) - 1;
+    };
+
+    /**
+        Returns the maximum value that can be stored in a `s16`.
+        @return Maximum value
+    */
+    fn s16_max() {
+        return s16((std::limits::u16_max() / 2));
+    };
+
+    /**
+        Returns the minimum value that can be stored in a `u32`.
+        @return Minimum value
+    */
+    fn u32_min() {
+        return u32(0);
+    };
+
+    /**
+        Returns the maximum value that can be stored in a `u32`.
+        @return Maximum value
+    */
+    fn u32_max() {
+        return u32(-1);
+    };
+
+    /**
+        Returns the minimum value that can be stored in a `s32`.
+        @return Minimum value
+    */
+    fn s32_min() {
+        return -s32((std::limits::u32_max() / 2)) - 1;
+    };
+
+    /**
+        Returns the maximum value that can be stored in a `s32`.
+        @return Maximum value
+    */
+    fn s32_max() {
+        return s32((std::limits::u32_max() / 2));
+    };
+
+    /**
+        Returns the minimum value that can be stored in a `u64`.
+        @return Minimum value
+    */
+    fn u64_min() {
+        return u64(0);
+    };
+
+    /**
+        Returns the maximum value that can be stored in a `u64`.
+        @return Maximum value
+    */
+    fn u64_max() {
+        return u64(-1);
+    };
+
+    /**
+        Returns the minimum value that can be stored in a `s64`.
+        @return Minimum value
+    */
+    fn s64_min() {
+        return -s64((std::limits::u64_max() / 2)) - 1;
+    };
+
+    /**
+        Returns the maximum value that can be stored in a `s64`.
+        @return Maximum value
+    */
+    fn s64_max() {
+        return s64((std::limits::u64_max() / 2));
+    };
+
+    /**
+        Returns the minimum value that can be stored in a `u128`.
+        @return Minimum value
+    */
+    fn u128_min() {
+        return u128(0);
+    };
+
+    /**
+        Returns the maximum value that can be stored in a `u128`.
+        @return Maximum value
+    */
+    fn u128_max() {
+        return u128(-1);
+    };
+
+    /**
+        Returns the minimum value that can be stored in a `s128`.
+        @return Minimum value
+    */
+    fn s128_min() {
+        return -s128((std::limits::u128_max() / 2)) - 1;
+    };
+
+    /**
+        Returns the maximum value that can be stored in a `s128`.
+        @return Maximum value
+    */
+    fn s128_max() {
+        return s128((std::limits::u128_max() / 2));
+    };
 
-	/**
-		Returns the minimum value that can be stored in a `u16`.
-		@return Minimum value
-	*/
-	fn u16_min() {
-		return u16(0);
-	};
-	
-	/**
-		Returns the maximum value that can be stored in a `u16`.
-		@return Maximum value
-	*/
-	fn u16_max() {
-		return u16(-1);
-	};
-	
-	/**
-		Returns the minimum value that can be stored in a `s16`.
-		@return Minimum value
-	*/
-	fn s16_min() {
-		return -s16((std::limits::u16_max() / 2)) - 1;
-	};
-	
-	/**
-		Returns the maximum value that can be stored in a `s16`.
-		@return Maximum value
-	*/
-	fn s16_max() {
-		return s16((std::limits::u16_max() / 2));
-	};
-	
-	/**
-		Returns the minimum value that can be stored in a `u32`.
-		@return Minimum value
-	*/
-	fn u32_min() {
-		return u32(0);
-	};
-	
-	/**
-		Returns the maximum value that can be stored in a `u32`.
-		@return Maximum value
-	*/
-	fn u32_max() {
-		return u32(-1);
-	};
-	
-	/**
-		Returns the minimum value that can be stored in a `s32`.
-		@return Minimum value
-	*/
-	fn s32_min() {
-		return -s32((std::limits::u32_max() / 2)) - 1;
-	};
-	
-	/**
-		Returns the maximum value that can be stored in a `s32`.
-		@return Maximum value
-	*/
-	fn s32_max() {
-		return s32((std::limits::u32_max() / 2));
-	};
-	
-	/**
-		Returns the minimum value that can be stored in a `u64`.
-		@return Minimum value
-	*/
-	fn u64_min() {
-		return u64(0);
-	};
-	
-	/**
-		Returns the maximum value that can be stored in a `u64`.
-		@return Maximum value
-	*/
-	fn u64_max() {
-		return u64(-1);
-	};
-	
-	/**
-		Returns the minimum value that can be stored in a `s64`.
-		@return Minimum value
-	*/
-	fn s64_min() {
-		return -s64((std::limits::u64_max() / 2)) - 1;
-	};
-	
-	/**
-		Returns the maximum value that can be stored in a `s64`.
-		@return Maximum value
-	*/
-	fn s64_max() {
-		return s64((std::limits::u64_max() / 2));
-	};
-	
-	/**
-		Returns the minimum value that can be stored in a `u128`.
-		@return Minimum value
-	*/
-	fn u128_min() {
-		return u128(0);
-	};
-	
-	/**
-		Returns the maximum value that can be stored in a `u128`.
-		@return Maximum value
-	*/
-	fn u128_max() {
-		return u128(-1);
-	};
-	
-	/**
-		Returns the minimum value that can be stored in a `s128`.
-		@return Minimum value
-	*/
-	fn s128_min() {
-		return -s128((std::limits::u128_max() / 2)) - 1;
-	};
-	
-	/**
-		Returns the maximum value that can be stored in a `s128`.
-		@return Maximum value
-	*/
-	fn s128_max() {
-		return s128((std::limits::u128_max() / 2));
-	};
-	
 }

includes/std/math.pat

@@ -1,339 +1,340 @@
 #pragma once
 
-#include <std/mem.pat>
+import std.mem;
 
 /*!
-	Library containing more advanced mathematical operations.
+    Library containing more advanced mathematical operations.
 */
 
-namespace std::math {
+namespace auto std::math {
-
-	/**
-		Compares the values `a` and `b` with each other and returns the smaller of the two
-		@param a First value
-		@param b Second value
-		@return `a` if `a` is smaller than `b`, otherwise `b`
-	*/
-	fn min(auto a, auto b) {
-		if (a < b)
-			return a;
-		else
-			return b;
-	};
-	
-	/**
-		Compares the values `a` and `b` with each other and returns the bigger of the two
-		@param a First value
-		@param b Second value
-		@return `a` if `a` is bigger than `b`, otherwise `b`
-	*/
-	fn max(auto a, auto b) {
-		if (a > b)
-			return a;
-		else
-			return b;
-	};
-
-	/**
-		Clamps the value of `x` between `min` and `max`.
-		@param x Value
-		@param min Minimum value
-		@param max Maximum value
-		@return `min` if `x` is smaller than `min`, `max` if `x` is bigger than `max`, `x` otherwise
-	*/
-	fn clamp(auto x, auto min, auto max) {
-		if (x < min)
-			return min;
-		else if (x > max)
-			return max;
-		else
-			return x;
-	};
-
-	/**
-		Returns the absolute value of `x`.
-		@param x Value
-		@return `x` if `x` is positive, `-x` otherwise
-	*/
-	fn abs(auto x) {
-		if (x < 0) 
-			return -x;
-		else 
-			return x;
-	};
-
-	/**
-		Returns the sign of `x`.
-		@param x Value
-		@return `1` if `x` is positive, `-1` if `x` is negative, `0` if `x` is zero
-	*/
-	fn sign(auto x) {
-		if (x > 0)
-			return 1;
-		else if (x < 0)
-			return -1;
-		else
-			return 0;
-	};
-
-	/**
-		Copies the sign of `y` to `x`.
-		@param x Value
-		@param y Value
-		@return `x` if `y` is positive, `-x` if `y` is negative
-	*/
-	fn copy_sign(auto x, auto y) {
-		if (y >= 0)
-			return std::math::abs(x);
-		else
-			return -std::math::abs(x);
-	};
-
-	/**
-		Calculates the factorial of `x`.
-		@param x Value
-		@return Factorial of `x`
-	*/
-	fn factorial(u128 x) {
-		u128 result;
-		
-		result = x;
-		while (x > 1) {
-			x = x - 1;
-			result = result * x;
-		}
-		
-		return result;
-	};
-
-	/**
-		Calculates the binomial coefficient of `n` and `k`.
-		@param n Value
-		@param k Value
-		@return Binomial coefficient of `n` and `k`
-	*/
-	fn comb(u128 n, u128 k) {
-		if (k > n)
-			return 0;
-		else
-			return std::math::factorial(n) / (std::math::factorial(k) * std::math::factorial(n - k));
-	};
-
-	/**
-		Calculates the permutation of `n` and `k`.
-		@param n Value
-		@param k Value
-		@return Permutation of `n` and `k`
-	*/
-	fn perm(u128 n, u128 k) {
-		if (k > n)
-			return 0;
-		else
-			return std::math::factorial(n) / std::math::factorial(n - k);
-	};
-
-	/**
-		Floors the value of `value`.
-		@param value Value
-		@return `value` floored
-	*/
-	fn floor(auto value) { return builtin::std::math::floor(value); };
-
-	/**
-		Ceils the value of `value`.
-		@param value Value
-		@return `value` ceiled
-	*/
-	fn ceil(auto value) { return builtin::std::math::ceil(value); };
-
-	/**
-		Rounds the value of `value`.
-		@param value Value
-		@return `value` rounded
-	*/
-	fn round(auto value) { return builtin::std::math::round(value); };
-
-	/**
-		Truncates the value of `value`.
-		@param value Value
-		@return `value` truncated
-	*/
-	fn trunc(auto value) { return builtin::std::math::trunc(value); };
-
-
-	/**
-		Calculates the logarithm of `value` with base 10.
-		@param value Value
-		@return Logarithm of `value` with base 10
-	*/
-	fn log10(auto value) { return builtin::std::math::log10(value); };
-
-	/**
-		Calculates the logarithm of `value` with base 2.
-		@param value Value
-		@return Logarithm of `value` with base 2
-	*/
-	fn log2(auto value) { return builtin::std::math::log2(value); };
-
-	/**
-		Calculates the natural logarithm of `value`.
-		@param value Value
-		@return Logarithm of `value` with base `e`
-	*/
-	fn ln(auto value) { return builtin::std::math::ln(value); };
-
-	/**
-		Calculates the floating point modulus of `value`.
-		@param value Value
-		@return Floating point modulus of `value`
-	*/
-	fn fmod(auto value) { return builtin::std::math::fmod(value); };
-
-	/**
-		Calculates the value of `base` raised to the power of `exp`.
-		@param base Base
-		@param exp Exponent
-		@return `base` raised to the power of `exp`
-	*/
-	fn pow(auto base, auto exp) { return builtin::std::math::pow(base, exp); };
 
     /**
-		Calculates the value of the natural number `e`	raised to the power of `value`.
+        Compares the values `a` and `b` with each other and returns the smaller of the two
-		@param value Exponent
+        @param a First value
-		@return `e` raised to the power of `value`
+        @param b Second value
-	*/
+        @return `a` if `a` is smaller than `b`, otherwise `b`
+    */
+    fn min(auto a, auto b) {
+        if (a < b)
+            return a;
+        else
+            return b;
+    };
+
+    /**
+        Compares the values `a` and `b` with each other and returns the bigger of the two
+        @param a First value
+        @param b Second value
+        @return `a` if `a` is bigger than `b`, otherwise `b`
+    */
+    fn max(auto a, auto b) {
+        if (a > b)
+            return a;
+        else
+            return b;
+    };
+
+    /**
+        Clamps the value of `x` between `min` and `max`.
+        @param x Value
+        @param min Minimum value
+        @param max Maximum value
+        @return `min` if `x` is smaller than `min`, `max` if `x` is bigger than `max`, `x` otherwise
+    */
+    fn clamp(auto x, auto min, auto max) {
+        if (x < min)
+            return min;
+        else if (x > max)
+            return max;
+        else
+            return x;
+    };
+
+    /**
+        Returns the absolute value of `x`.
+        @param x Value
+        @return `x` if `x` is positive, `-x` otherwise
+    */
+    fn abs(auto x) {
+        if (x < 0)
+            return -x;
+        else
+            return x;
+    };
+
+    /**
+        Returns the sign of `x`.
+        @param x Value
+        @return `1` if `x` is positive, `-1` if `x` is negative, `0` if `x` is zero
+    */
+    fn sign(auto x) {
+        if (x > 0)
+            return 1;
+        else if (x < 0)
+            return -1;
+        else
+            return 0;
+    };
+
+    /**
+        Copies the sign of `y` to `x`.
+        @param x Value
+        @param y Value
+        @return `x` if `y` is positive, `-x` if `y` is negative
+    */
+    fn copy_sign(auto x, auto y) {
+        if (y >= 0)
+            return std::math::abs(x);
+        else
+            return -std::math::abs(x);
+    };
+
+    /**
+        Calculates the factorial of `x`.
+        @param x Value
+        @return Factorial of `x`
+    */
+    fn factorial(u128 x) {
+        u128 result;
+
+        result = x;
+        while (x > 1) {
+            x = x - 1;
+            result = result * x;
+        }
+
+        return result;
+    };
+
+    /**
+        Calculates the binomial coefficient of `n` and `k`.
+        @param n Value
+        @param k Value
+        @return Binomial coefficient of `n` and `k`
+    */
+    fn comb(u128 n, u128 k) {
+        if (k > n)
+            return 0;
+        else
+            return std::math::factorial(n) / (std::math::factorial(k) * std::math::factorial(n - k));
+    };
+
+    /**
+        Calculates the permutation of `n` and `k`.
+        @param n Value
+        @param k Value
+        @return Permutation of `n` and `k`
+    */
+    fn perm(u128 n, u128 k) {
+        if (k > n)
+            return 0;
+        else
+            return std::math::factorial(n) / std::math::factorial(n - k);
+    };
+
+    /**
+        Floors the value of `value`.
+        @param value Value
+        @return `value` floored
+    */
+    fn floor(auto value) { return builtin::std::math::floor(value); };
+
+    /**
+        Ceils the value of `value`.
+        @param value Value
+        @return `value` ceiled
+    */
+    fn ceil(auto value) { return builtin::std::math::ceil(value); };
+
+    /**
+        Rounds the value of `value`.
+        @param value Value
+        @return `value` rounded
+    */
+    fn round(auto value) { return builtin::std::math::round(value); };
+
+    /**
+        Truncates the value of `value`.
+        @param value Value
+        @return `value` truncated
+    */
+    fn trunc(auto value) { return builtin::std::math::trunc(value); };
+
+
+    /**
+        Calculates the logarithm of `value` with base 10.
+        @param value Value
+        @return Logarithm of `value` with base 10
+    */
+    fn log10(auto value) { return builtin::std::math::log10(value); };
+
+    /**
+        Calculates the logarithm of `value` with base 2.
+        @param value Value
+        @return Logarithm of `value` with base 2
+    */
+    fn log2(auto value) { return builtin::std::math::log2(value); };
+
+    /**
+        Calculates the natural logarithm of `value`.
+        @param value Value
+        @return Logarithm of `value` with base `e`
+    */
+    fn ln(auto value) { return builtin::std::math::ln(value); };
+
+    /**
+        Calculates the floating point modulus of `value`.
+        @param value Value
+        @return Floating point modulus of `value`
+    */
+    fn fmod(auto value) { return builtin::std::math::fmod(value); };
+
+    /**
+        Calculates the value of `base` raised to the power of `exp`.
+        @param base Base
+        @param exp Exponent
+        @return `base` raised to the power of `exp`
+    */
+    fn pow(auto base, auto exp) { return builtin::std::math::pow(base, exp); };
+
+    /**
+        Calculates the value of the natural number `e`    raised to the power of `value`.
+        @param value Exponent
+        @return `e` raised to the power of `value`
+    */
     fn exp(auto value) { return builtin::std::math::exp(value); };
 
-	/**
+    /**
-		Calculates the square root of `value`.
+        Calculates the square root of `value`.
-		@param value Value
+        @param value Value
-		@return Square root of `value`
+        @return Square root of `value`
-	*/
+    */
-	fn sqrt(auto value) { return builtin::std::math::sqrt(value); };
+    fn sqrt(auto value) { return builtin::std::math::sqrt(value); };
 
-	/**
+    /**
-		Calculates the cubic root of `value`.
+        Calculates the cubic root of `value`.
-		@param value Value
+        @param value Value
-		@return Cubic root of `value`
+        @return Cubic root of `value`
-	*/
+    */
-	fn cbrt(auto value) { return builtin::std::math::cbrt(value); };
+    fn cbrt(auto value) { return builtin::std::math::cbrt(value); };
 
-	/**
+    /**
-		Calculates the sine of `value`.
+        Calculates the sine of `value`.
-		@param value Angle value in radians
+        @param value Angle value in radians
-		@return Sine of `value`
+        @return Sine of `value`
-	*/
+    */
-	fn sin(auto value) { return builtin::std::math::sin(value); };
+    fn sin(auto value) { return builtin::std::math::sin(value); };
 
-	/**
+    /**
-		Calculates the cosine of `value`.
+        Calculates the cosine of `value`.
-		@param value Angle value in radians
+        @param value Angle value in radians
-		@return Cosine of `value`
+        @return Cosine of `value`
-	*/
+    */
-	fn cos(auto value) { return builtin::std::math::cos(value); };
+    fn cos(auto value) { return builtin::std::math::cos(value); };
 
-	/**
+    /**
-		Calculates the tangent of `value`.
+        Calculates the tangent of `value`.
-		@param value Angle value in radians
+        @param value Angle value in radians
-		@return Tangent of `value`
+        @return Tangent of `value`
-	*/
+    */
-	fn tan(auto value) { return builtin::std::math::tan(value); };
+    fn tan(auto value) { return builtin::std::math::tan(value); };
 
-	/**
+    /**
-		Calculates the arc sine of `value`.
+        Calculates the arc sine of `value`.
-		@param value Angle value in radians
+        @param value Angle value in radians
-		@return Arc sine of `value`
+        @return Arc sine of `value`
-	*/
+    */
-	fn asin(auto value) { return builtin::std::math::asin(value); };
+    fn asin(auto value) { return builtin::std::math::asin(value); };
 
-	/**
+    /**
-		Calculates the arc cosine of `value`.
+        Calculates the arc cosine of `value`.
-		@param value Value
+        @param value Value
-		@return Arc cosine of `value` in radians
+        @return Arc cosine of `value` in radians
-	*/
+    */
-	fn acos(auto value) { return builtin::std::math::acos(value); };
+    fn acos(auto value) { return builtin::std::math::acos(value); };
 
-	/**
+    /**
-		Calculates the arc tangent of `value`.
+        Calculates the arc tangent of `value`.
-		@param value Value
+        @param value Value
-		@return Arc tangent of `value` in radians between `-pi/2` and `pi/2`
+        @return Arc tangent of `value` in radians between `-pi/2` and `pi/2`
-	*/
+    */
-	fn atan(auto value) { return builtin::std::math::atan(value); };
+    fn atan(auto value) { return builtin::std::math::atan(value); };
 
-	/**
+    /**
-		Calculates the arc tangent of `value`.
+        Calculates the arc tangent of `value`.
-		@param value Value
+        @param y Value representing the proportion of the y-coordinate
-		@return Arc tangent of `value` in radians between `-pi` and `pi`
+        @param x Value representing the proportion of the x-coordinate.
-	*/
+        @return Arc tangent of `value` in radians between `-pi` and `pi`
-	fn atan2(auto value) { return builtin::std::math::atan2(value); };
+    */
+    fn atan2(auto y, auto x) { return builtin::std::math::atan2(y, x); };
 
-	/**
+    /**
-		Calculates the hyperbolic sine of `value`.
+        Calculates the hyperbolic sine of `value`.
-		@param value Angle value in radians
+        @param value Angle value in radians
-		@return Hyperbolic sine of `value`
+        @return Hyperbolic sine of `value`
-	*/
+    */
-	fn sinh(auto value) { return builtin::std::math::sinh(value); };
+    fn sinh(auto value) { return builtin::std::math::sinh(value); };
 
-	/**
+    /**
-		Calculates the hyperbolic cosine of `value`.
+        Calculates the hyperbolic cosine of `value`.
-		@param value Angle value in radians
+        @param value Angle value in radians
-		@return Hyperbolic cosine of `value`
+        @return Hyperbolic cosine of `value`
-	*/
+    */
-	fn cosh(auto value) { return builtin::std::math::cosh(value); };
+    fn cosh(auto value) { return builtin::std::math::cosh(value); };
 
-	/**
+    /**
-		Calculates the hyperbolic tangent of `value`.
+        Calculates the hyperbolic tangent of `value`.
-		@param value Angle value in radians
+        @param value Angle value in radians
-		@return Hyperbolic tangent of `value`
+        @return Hyperbolic tangent of `value`
-	*/
+    */
-	fn tanh(auto value) { return builtin::std::math::tanh(value); };
+    fn tanh(auto value) { return builtin::std::math::tanh(value); };
 
 
-	/**
+    /**
-		Calculates the arc hyperbolic sine of `value`.
+        Calculates the arc hyperbolic sine of `value`.
-		@param value Value
+        @param value Value
-		@return Arc hyperbolic sine of `value`
+        @return Arc hyperbolic sine of `value`
-	*/
+    */
-	fn asinh(auto value) { return builtin::std::math::asinh(value); };
+    fn asinh(auto value) { return builtin::std::math::asinh(value); };
 
-	/**
+    /**
-		Calculates the arc hyperbolic cosine of `value`.
+        Calculates the arc hyperbolic cosine of `value`.
-		@param value Value
+        @param value Value
-		@return Arc hyperbolic cosine of `value`
+        @return Arc hyperbolic cosine of `value`
-	*/
+    */
-	fn acosh(auto value) { return builtin::std::math::acosh(value); };
+    fn acosh(auto value) { return builtin::std::math::acosh(value); };
 
-	/**
+    /**
-		Calculates the arc hyperbolic tangent of `value`.
+        Calculates the arc hyperbolic tangent of `value`.
-		@param value Value
+        @param value Value
-		@return Arc hyperbolic tangent of `value`
+        @return Arc hyperbolic tangent of `value`
-	*/
+    */
-	fn atanh(auto value) { return builtin::std::math::atanh(value); };
+    fn atanh(auto value) { return builtin::std::math::atanh(value); };
 
 
-	/**
+    /**
-		Options to use with the `std::math::accumulate` function.
+        Options to use with the `std::math::accumulate` function.
-	*/
+    */
-	enum AccumulateOperation : u8 {
+    enum AccumulateOperation : u8 {
-		Add 		= 0,
+        Add         = 0,
-		Multiply 	= 1,
+        Multiply    = 1,
-		Modulo 		= 2,
+        Modulo      = 2,
-		Min 		= 3,
+        Min         = 3,
-		Max 		= 4
+        Max         = 4
-	};
+    };
+
+    /**
+        Calculates the sum of all values in the specified memory range.
+        @param start Start address
+        @param end End address
+        @param valueSize Size of each value in bytes
+        @param [section] Section to use
+        @param [operation] Operation to use. Defaults to addition
+        @param [endian] Endianness to use. Defaults to native
+        @return Sum of all values in the specified memory range
+    */
+    fn accumulate(u128 start, u128 end, u128 valueSize, std::mem::Section section = 0, AccumulateOperation operation = AccumulateOperation::Add, std::mem::Endian endian = std::mem::Endian::Native) {
+        return builtin::std::math::accumulate(start, end, valueSize, section, u128(operation), u128(endian));
+    };
 
-	/**
-		Calculates the sum of all values in the specified memory range.
-		@param start Start address
-		@param end End address
-		@param valueSize Size of each value in bytes
-		@param section Section to use
-		@param operation Operation to use
-		@param endian Endianness to use
-		@return Sum of all values in the specified memory range
-	*/
-	fn accumulate(u128 start, u128 end, u128 valueSize, std::mem::Section section = 0, AccumulateOperation operation = AccumulateOperation::Add, std::mem::Endian endian = std::mem::Endian::Native) {
-		return builtin::std::math::accumulate(start, end, valueSize, section, u128(operation), u128(endian));
-	};
-	
 }

includes/std/mem.pat

@@ -4,15 +4,17 @@
     Library for doing raw memory accesses and other low-level operations.
 */
 
-namespace std::mem {
+namespace auto std::mem {
-  
+
     /**
         A Handle for a custom Section
      */
     using Section = u128;
+    const u64 SectionMain = 0;
+    const u64 SectionCurrent = 0xFFFF'FFFF'FFFF'FFFF;
 
     /**
-        The Endianess of a value
+        The endianness of a value
      */
     enum Endian : u8 {
         Native  = 0,
@@ -26,7 +28,16 @@ namespace std::mem {
         @return True if the cursor is at the end of the memory
      */
     fn eof() {
-        return $ >= std::mem::size();
+        return $ >= (std::mem::base_address() + std::mem::size());
+    };
+
+    /**
+        Function that returns true if the cursor position is at or beyond the given address
+        @param address The address to compare against
+        @return True if the cursor is at or beyond the given address
+    */
+    fn reached(u128 address) {
+        return $ >= address;
     };
 
     /**
@@ -40,36 +51,37 @@ namespace std::mem {
 
         return remainder != 0 ? value + (alignment - remainder) : value;
     };
-  
+
 
     /**
-        Gets the base address of the memory
+        Gets the base address of the data
         @return The base address of the memory
      */
-    fn base_address() {
+    fn base_address(u64 section = SectionCurrent) {
-        return builtin::std::mem::base_address();
+        return builtin::std::mem::base_address(section);
     };
 
     /**
-        Gets the size of the memory
+        Gets the size of the data
         @return The size of the memory
      */
-    fn size() {
+    fn size(u64 section = SectionCurrent) {
-        return builtin::std::mem::size();
+        return builtin::std::mem::size(section);
     };
 
     /**
-        Finds a sequence of bytes in the memory
+        Finds a sequence of bytes in the data
         @param occurrence_index The index of the occurrence to find
         @param bytes The bytes to find
         @return The address of the sequence
     */
     fn find_sequence(u128 occurrence_index, auto ... bytes) {
-        return builtin::std::mem::find_sequence_in_range(occurrence_index, builtin::std::mem::base_address(), builtin::std::mem::size(), bytes);
+        const u128 address = std::mem::base_address();
+        return builtin::std::mem::find_sequence_in_range(occurrence_index, address, address + std::mem::size(), bytes);
     };
 
     /**
-        Finds a sequence of bytes in a specific region of the memory
+        Finds a sequence of bytes in a specific region of the data
         @param occurrence_index The index of the occurrence to find
         @param offsetFrom The offset from which to start searching
         @param offsetTo The offset to which to search
@@ -80,26 +92,50 @@ namespace std::mem {
         return builtin::std::mem::find_sequence_in_range(occurrence_index, offsetFrom, offsetTo, bytes);
     };
 
+
+    /**
+        Finds a string in the data
+        @param occurrence_index The index of the occurrence to find
+        @param string The string to find
+        @return The address of the sequence
+    */
+    fn find_string(u128 occurrence_index, str string) {
+        const u128 address = std::mem::base_address();
+        return builtin::std::mem::find_string_in_range(occurrence_index, address, address + std::mem::size(), string);
+    };
+
+    /**
+        Finds a string in a specific region of the data
+        @param occurrence_index The index of the occurrence to find
+        @param offsetFrom The offset from which to start searching
+        @param offsetTo The offset to which to search
+        @param string The string to find
+        @return The address of the sequence
+    */
+    fn find_string_in_range(u128 occurrence_index, u128 offsetFrom, u128 offsetTo, str string) {
+        return builtin::std::mem::find_string_in_range(occurrence_index, offsetFrom, offsetTo, string);
+    };
+
     /**
         Reads a unsigned value from the memory
         @param address The address to read from
         @param size The size of the value to read
-        @param endian The endianess of the value to read
+        @param [endian] The endianness of the value to read. Defaults to native
         @return The value read
     */
-    fn read_unsigned(u128 address, u8 size, Endian endian = Endian::Native) {
+    fn read_unsigned(u128 address, u8 size, Endian endian = Endian::Native, Section section = SectionCurrent) {
-        return builtin::std::mem::read_unsigned(address, size, u32(endian));
+        return builtin::std::mem::read_unsigned(address, size, u32(endian), section);
     };
 
     /**
         Reads a signed value from the memory
         @param address The address to read from
         @param size The size of the value to read
-        @param endian The endianess of the value to read
+        @param [endian] The endianness of the value to read. Defaults to native
         @return The value read
     */
-    fn read_signed(u128 address, u8 size, Endian endian = Endian::Native) {
+    fn read_signed(u128 address, u8 size, Endian endian = Endian::Native, Section section = SectionCurrent) {
-        return builtin::std::mem::read_signed(address, size, u32(endian));
+        return builtin::std::mem::read_signed(address, size, u32(endian), section);
     };
 
     /**
@@ -108,16 +144,8 @@ namespace std::mem {
         @param size The size of the value to read
         @return The value read
     */
-    fn read_string(u128 address, u8 size) {
+    fn read_string(u128 address, u128 size, Section section = SectionCurrent) {
-        return builtin::std::mem::read_string(address, size);
+        return builtin::std::mem::read_string(address, size, section);
-    };
-
-
-    /**
-        Gets the current bit offset within the current byte that a bitfield will read.
-    */
-    fn current_bit_offset() {
-        return builtin::std::mem::current_bit_offset();
     };
 
     /**
@@ -160,6 +188,15 @@ namespace std::mem {
         return builtin::std::mem::get_section_size(section);
     };
 
+    /**
+        Changes the size of a custom section
+        @param section The handle to the section
+        @param size The new size of the section
+    */
+    fn set_section_size(Section section, u128 size) {
+        builtin::std::mem::set_section_size(section, size);
+    };
+
     /**
         Copies a range of bytes from one section into another
         @param from_section The section to copy from
@@ -182,26 +219,12 @@ namespace std::mem {
         builtin::std::mem::copy_value_to_section(value, to_section, to_address);
     };
 
-
     /**
-        Searches for a sequence of bytes and places the given type at that address
+        Returns the current bit offset when inside of a bitfield.
-        @tparam Magic The magic sequence to search for
+        @return The current bit offset between 0 and 7
-        @tparam T The type to place at the address
     */
-    struct MagicSearch<auto Magic, T> {
+    fn current_bit_offset() {
-        if ($ < (std::mem::size() - std::string::length(Magic) - 1)) {
+        return builtin::std::mem::current_bit_offset();
-            char __potentialMagic__[std::string::length(Magic)] [[hidden, no_unique_address]];
-            
-            if (__potentialMagic__ == Magic) {
-                T data [[inline]];
-            } else {
-                padding[1];
-                continue;
-            }
-        } else {
-            padding[1];
-            continue;
-        }
     };
 
     /**
@@ -210,10 +233,10 @@ namespace std::mem {
         @tparam To The type to reinterpret to
     */
     union Reinterpreter<From, To> {
-        From from;
+        From from_value;
-        To to;
+        To to_value;
     };
-  
+
 
     /**
         Aligns the cursor to the given alignment
@@ -232,11 +255,33 @@ namespace std::mem {
     } [[sealed, format("std::mem::impl::format_bytes")]];
 
     namespace impl {
-      
+
         fn format_bytes(auto bytes) {
             return "";
         };
-      
+
+        struct MagicSearchImpl<auto Magic, T> {
+            s128 address = builtin::std::mem::find_string_in_range(0, $, std::mem::size(), Magic);
+            if (address < 0)
+                break;
+
+            $ = address;
+            try {
+                T data [[inline]];
+            } catch {
+                T data;
+            }
+        };
+
     }
 
+    /**
+        Searches for a sequence of bytes and places the given type at that address
+        @tparam Magic The magic sequence to search for
+        @tparam T The type to place at the address
+    */
+    struct MagicSearch<auto Magic, T> {
+        std::mem::impl::MagicSearchImpl<Magic, T> impl[while(!std::mem::eof())] [[inline]];
+    };
+
 }

includes/std/ptr.pat

@@ -1,11 +1,13 @@
 #pragma once
 
+import std.mem;
+
 /*!
     The Pointer library contains helper functions to deal with pointer types.
     The `relative_to` functions are meant to be used with the `[[pointer_base]]` attribute
 */
 
-namespace std::ptr {
+namespace auto std::ptr {
 
     /**
         Use the offset of the current pointer as start address
@@ -45,9 +47,9 @@ namespace std::ptr {
     Example:
     A struct field called `p_myInfo` which is a nullable 64-bit pointer to an
     element of type `MyInfoTy` would be written as:
-    ```
+    ```rust
     struct MyStruct {
-      std::ptr::NullablePtr<MyInfoTy, u64> p_myInfo;
+        std::ptr::NullablePtr<MyInfoTy, u64> p_myInfo;
     }
     ```
     */
@@ -55,7 +57,7 @@ namespace std::ptr {
         // `pointerValue` is `no_unique_address` because we don't want to advance
         // the current memory location after reading the value of the pointer itself;
         // we want to examine the value at this address to determine what should be
-        // displayed. It's also `hidden` so the editor only displays either thee 
+        // displayed. It's also `hidden` so the editor only displays either thee
         // padding or the populated pointer/pointee field.
         PointerTy pointerValue [[no_unique_address, hidden]];
         if (pointerValue == 0x0) {
@@ -64,4 +66,4 @@ namespace std::ptr {
             PointeeTy *data : PointerTy;
         }
     };
-}
+}

includes/std/random.pat

@@ -1,13 +1,13 @@
 #pragma once
 
-#include <std/limits.pat>
+import std.limits;
 
 /*!
   Library to generate random numbers. Supports various different distribution types.
 */
 
-namespace std::random {
+namespace auto std::random {
-  
+
     /**
         Represents the type of distribution to use to generate a random number
     */
@@ -61,21 +61,21 @@ namespace std::random {
         > - `Poisson(mean) -> i128`
 
         @param distribution Distribution to use
-        @param param1 This parameter depends on the type of distribution used.
+        @param [param1] This parameter depends on the type of distribution used. Defaults to 0
-        @param param2 This parameter depends on the type of distribution used.
+        @param [param2] This parameter depends on the type of distribution used. Defaults to 0
     */
     fn generate_using(Distribution distribution, auto param1 = 0, auto param2 = 0) {
         return builtin::std::random::generate(u32(distribution), param1, param2);
     };
 
-    
+
     /**
         Generates a uniformly distributed random number between `min` and `max`
-        @param min Minimum number
+        @param [min] Minimum number. Defaults to 0
-        @param max Maximum number
+        @param [max] Maximum number. Defaults to `u64_max`
     */
     fn generate(u64 min = std::limits::u64_min(), u64 max = std::limits::u64_max()) {
         return std::random::generate_using(Distribution::Uniform, min, max);
     };
-  
+
 }

includes/std/string.pat

@@ -1,129 +1,153 @@
 #pragma once
 
-#include <std/io.pat>
+import std.io;
+import std.mem;
 
 /*!
-	Libray to interact with strings.
+    Library to interact with strings.
 */
 
-namespace std::string {
+namespace auto std::string {
 
-	/**
+    /**
-	    Base type for sized strings. Represents a string with its size preceeding it.
+        Base type for sized strings. Represents a string with its size preceding it.
-		@tparam SizeType The type of the size field.
+        @tparam SizeType The type of the size field.
-		@tparam DataType The type of the characters.
+        @tparam DataType The type of the characters.
-	*/
+    */
-	struct SizedStringBase<SizeType, DataType> {
+    struct SizedStringBase<SizeType, DataType> {
-		SizeType size;
+        SizeType size;
-		DataType data[size];
+        DataType data[size];
-	} [[sealed, format("std::string::impl::format_sized_string"), transform("std::string::impl::format_sized_string")]];
+    } [[sealed, format("std::string::impl::format_string"), transform("std::string::impl::format_string")]];
 
-	/**
+    /**
-	    A ASCII string with a prefixed size.
+        A ASCII string with a prefixed size.
-		@tparam SizeType The type of the size field.
+        @tparam SizeType The type of the size field.
-	*/
+    */
-	using SizedString<SizeType> = SizedStringBase<SizeType, char>;
+    using SizedString<SizeType> = SizedStringBase<SizeType, char>;
 
-	/**
+    /**
-	    A UTF-16 string with a prefixed size.
+        A UTF-16 string with a prefixed size.
-		@tparam SizeType The type of the size field.
+        @tparam SizeType The type of the size field.
-	*/
+    */
-	using SizedString16<SizeType> = SizedStringBase<SizeType, char16>;
+    using SizedString16<SizeType> = SizedStringBase<SizeType, char16>;
 
-	namespace impl {
+    /**
+        Base type for null-terminated strings. Represents a string with its size determined by the first 0x00 byte found.
+        @tparam DataType The type of the characters.
+    */
+    struct NullStringBase<DataType> {
+        DataType data[while(std::mem::read_unsigned($, sizeof(DataType)) != 0x00)];
+        DataType null_terminator;
+    } [[sealed, format("std::string::impl::format_string"), transform("std::string::impl::format_string")]];
 
-		fn format_sized_string(ref auto string) {
+    /**
-			return string.data;
+        A null-terminated ASCII string.
-		};
+    */
+    using NullString = NullStringBase<char>;
 
-	}
+    /**
+        A null-terminated UTF-16 string.
+    */
+    using NullString16 = NullStringBase<char16>;
 
-	/**
+    namespace impl {
-		Gets the length of a string.
-		@param string The string to get the length of.
-		@return The length of the string.
-	*/
-	fn length(str string) {
-		return builtin::std::string::length(string);
-	};
 
-	/**
+        fn format_string(ref auto string) {
-		Gets the character at a given index.
+            return string.data;
-		@param string The string to get the character from.
+        };
-		@param index The index of the character to get.
-		@return The character at the given index.
-	*/
-	fn at(str string, u32 index) {
-		return builtin::std::string::at(string, index);
-	};
 
-	/**
+    }
-		Gets a substring of a string.
+
-		@param string The string to get the substring from.
+    /**
-		@param pos The position of the first character of the substring.
+        Gets the length of a string.
-		@param count The number of characters to get.
+        @param string The string to get the length of.
-		@return The substring.
+        @return The length of the string.
-	*/
+    */
-	fn substr(str string, u32 pos, u32 count) {
+    fn length(str string) {
-		return builtin::std::string::substr(string, pos, count);
+        return builtin::std::string::length(string);
-	};
+    };
+
+    /**
+        Gets the character at a given index.
+        @param string The string to get the character from.
+        @param index The index of the character to get.
+        @return The character at the given index.
+    */
+    fn at(str string, u32 index) {
+        return builtin::std::string::at(string, index);
+    };
+
+    /**
+        Gets a substring of a string.
+        @param string The string to get the substring from.
+        @param pos The position of the first character of the substring.
+        @param count The number of characters to get.
+        @return The substring.
+    */
+    fn substr(str string, u32 pos, u32 count) {
+        return builtin::std::string::substr(string, pos, count);
+    };
 
 
-	/**
+    /**
-		Converts a string to an integer.
+        Converts a string to an integer.
-		@param string The string to convert.
+        @param string The string to convert.
-		@param base The base of the number.
+        @param base The base of the number.
-		@return The integer.
+        @return The integer.
-	*/
+    */
-	fn parse_int(str string, u8 base) {
+    fn parse_int(str string, u8 base) {
-		return builtin::std::string::parse_int(string, base);
+        return builtin::std::string::parse_int(string, base);
-	};
+    };
 
-	/**
+    /**
-		Converts a string to a float.
+        Converts a string to a float.
-		@param string The string to convert.
+        @param string The string to convert.
-		@return The float.
+        @return The float.
-	*/
+    */
-	fn parse_float(str string) {
+    fn parse_float(str string) {
-		return builtin::std::string::parse_float(string);
+        return builtin::std::string::parse_float(string);
-	};
+    };
 
 
-	/**
+    /**
-		Converts any type to a string.
+        Converts any type to a string.
-		@param x The value to convert.
+        @param x The value to convert.
-		@return The string.
+        @return The string.
-	*/
+    */
     fn to_string(auto x) {
         return std::format("{}", x);
     };
 
-	/**
+    /**
-		Checks if a string starts with a given substring.
+        Checks if a string starts with a given substring.
-		@param string The string to check.
+        @param string The string to check.
-		@param part The substring to check for.
+        @param part The substring to check for.
-		@return True if the string starts with the substring, false otherwise.
+        @return True if the string starts with the substring, false otherwise.
-	*/
+    */
     fn starts_with(str string, str part) {
+        if (std::string::length(string) < std::string::length(part))
+            return false;
         return std::string::substr(string, 0, std::string::length(part)) == part;
     };
 
-	/**
+    /**
-		Checks if a string ends with a given substring.
+        Checks if a string ends with a given substring.
-		@param string The string to check.
+        @param string The string to check.
-		@param part The substring to check for.
+        @param part The substring to check for.
-		@return True if the string ends with the substring, false otherwise.
+        @return True if the string ends with the substring, false otherwise.
-	*/
+    */
     fn ends_with(str string, str part) {
+        if (std::string::length(string) < std::string::length(part))
+            return false;
         return std::string::substr(string, std::string::length(string) - std::string::length(part), std::string::length(part)) == part;
     };
 
-	/**
+    /**
-		Checks if a string contains a given substring.
+        Checks if a string contains a given substring.
-		@param string The string to check.
+        @param string The string to check.
-		@param part The substring to check for.
+        @param part The substring to check for.
-		@return True if the string contains the substring, false otherwise.
+        @return True if the string contains the substring, false otherwise.
-	*/
+    */
     fn contains(str string, str part) {
         s32 string_len = std::string::length(string);
         s32 part_len = std::string::length(part);
@@ -136,103 +160,100 @@ namespace std::string {
         return false;
     };
 
-	/**
+    /**
-		Reverses a string.
+        Reverses a string.
-		@param string The string to reverse.
+        @param string The string to reverse.
-		@return The reversed string.
+        @return The reversed string.
-	*/
+    */
-    fn reverse(str string) {	
+    fn reverse(str string) {
         str result;
-        
+
         s32 i;
         i = std::string::length(string);
         while (i > 0) {
             i = i - 1;
             result = result + std::string::at(string, i);
         }
-            
+
         return result;
     };
 
-	/**
+    /**
-		Converts a string to upper case.
+        Converts a string to upper case.
-		@param string The string to convert.
+        @param string The string to convert.
-		@return The converted string.
+        @return The converted string.
-	*/
+    */
     fn to_upper(str string) {
-		str result;
+        str result;
-		
-		u32 i;
-		char c;
-		while (i < std::string::length(string)) {
-			c = std::string::at(string, i);
-			
-			if (c >= 'a' && c <= 'z')
-				result = result + char(c - 0x20);
-			else
-				result = result + c;
-			
-			i = i + 1;
-		}
-		
-		return result;
-	};
-	
-	/**
-		Converts a string to lower case.
-		@param string The string to convert.
-		@return The converted string.
-	*/
-	fn to_lower(str string) {
-		str result;
-		
-		u32 i;
-		char c;
-		while (i < std::string::length(string)) {
-			c = std::string::at(string, i);
-			
-			if (c >= 'A' && c <= 'Z')
-				result = result + char(c + 0x20);
-			else
-				result = result + c;
-			
-			i = i + 1;
-		}
-		
-		return result;
-	};
 
-	/**
+        u32 i;
-		Replaces all occurrences of a substring with another substring.
+        char c;
-		@param string The string to replace in.
+        while (i < std::string::length(string)) {
-		@param pattern The substring to replace.
+            c = std::string::at(string, i);
-		@param replace The substring to replace with.
+
-		@return The string with the replacements.
+            if (c >= 'a' && c <= 'z')
-	*/
+                result = result + char(c - 0x20);
+            else
+                result = result + c;
+
+            i = i + 1;
+        }
+
+        return result;
+    };
+
+    /**
+        Converts a string to lower case.
+        @param string The string to convert.
+        @return The converted string.
+    */
+    fn to_lower(str string) {
+        str result;
+
+        u32 i;
+        char c;
+        while (i < std::string::length(string)) {
+            c = std::string::at(string, i);
+
+            if (c >= 'A' && c <= 'Z')
+                result = result + char(c + 0x20);
+            else
+                result = result + c;
+
+            i = i + 1;
+        }
+
+        return result;
+    };
+
+    /**
+        Replaces all occurrences of a substring with another substring.
+        @param string The string to replace in.
+        @param pattern The substring to replace.
+        @param replace The substring to replace with.
+        @return The string with the replacements.
+    */
     fn replace(str string, str pattern, str replace) {
-    	u32 string_len, pattern_len, replace_len;
+        s32 string_len  = std::string::length(string);
-		string_len  = std::string::length(string);
+        s32 pattern_len = std::string::length(pattern);
-		pattern_len = std::string::length(pattern);
-		replace_len = std::string::length(replace);
-		
-		if (pattern_len > string_len)
-			return string;
-			
-		str result;
-		u32 i;
-		while (i <= (string_len - pattern_len)) {
-			
-			if (std::string::substr(string, i, pattern_len) == pattern) {
-				result = result + replace;
-				i = i + pattern_len;
-			} else {
-				result = result + std::string::at(string, i);
-				i = i + 1;
-			}
-		}
-		
-		return result;
-	};
 
+        if (pattern_len > string_len || pattern_len * string_len == 0 )
+             return string;
 
+        str result;
+        s32 string_index;
+        s32 remaining_len = string_len;
+        while (pattern_len <= remaining_len) {
+            if (std::string::substr(string, string_index, pattern_len) == pattern) {
+                 result += replace;
+                string_index += pattern_len;
+             } else {
+                result += std::string::at(string, string_index);
+                  string_index += 1;
+            }
+            remaining_len = string_len - string_index;
+        }
+        result += std::string::substr(string, string_index, remaining_len );
+        return result;
+    };
 }

includes/std/sys.pat

@@ -1,16 +1,16 @@
 #pragma once
 
-#include <std/io.pat>
+import std.io;
 
 /*!
     Basic helper functions
 */
 
-namespace std {
+namespace auto std {
 
     /**
         Asserts that a given value is true. If it's not, abort evaluation and print the given message to the console
-        @param conditoon The condition that is required to be true
+        @param condition The condition that is required to be true
         @param message The message to print in case the assertion doesn't hold
     */
     fn assert(bool condition, str message) {
@@ -21,7 +21,7 @@ namespace std {
 
     /**
         Asserts that a given value is true. If it's not, print the given message to the console as a warning
-        @param conditoon The condition that is required to be true
+        @param condition The condition that is required to be true
         @param message The message to print in case the assertion doesn't hold
     */
     fn assert_warn(bool condition, str message) {
@@ -49,4 +49,11 @@ namespace std {
         return builtin::std::sizeof_pack(pack);
     };
 
+    /**
+        Throws an error notifying the developer that the current code path is not implemented currently.
+    */
+    fn unimplemented() {
+        std::error("Unimplemented code path reached!");
+    };
+
 }

includes/std/time.pat

@@ -1,191 +1,200 @@
 #pragma once
 
-#include <std/io.pat>
+import std.io;
 
 /*!
-	Library to handle time and date related operations.
+    Library to handle time and date related operations.
 */
 
-namespace std::time {
+namespace auto std::time {
 
-	/**
+    /**
-		A structured representation of a time and date.
+        A structured representation of a time and date.
-	*/
+    */
-	struct Time {
+    struct Time {
-		u8 sec;
+        u8 sec;
-		u8 min;
+        u8 min;
-		u8 hour;
+        u8 hour;
-		u8 mday;
+        u8 mday;
-		u8 mon;
+        u8 mon;
-		u16 year;
+        u16 year;
-		u8 wday;
+        u8 wday;
-		u16 yday;
+        u16 yday;
-		bool isdst;
+        bool isdst;
-	} [[sealed]];
+    } [[sealed]];
 
-	/**
+    /**
-		A helper type to convert between Time and u128.
+        A helper type to convert between Time and u128.
-	*/
+    */
-	union TimeConverter {
+    union TimeConverter {
-		Time time;
+        Time time;
-		u128 value;
+        u128 value;
-	};
+    };
 
-	/**
+    /**
-		A type to represent a time in seconds since the epoch.
+        A type to represent a time in seconds since the epoch.
-	*/
+    */
-	using EpochTime = u128;
+    using EpochTime = u32;
 
-	/**
+    /**
-		A type to represent a time zone.
+        A type to represent a time zone.
-	*/
+    */
-	enum TimeZone : u8 {
+    enum TimeZone : u8 {
-		Local,
+        Local,
-		UTC
+        UTC
-	};
+    };
 
-	/**
+    /**
-		A type to represent a DOS date.
+        A type to represent a DOS date.
-	*/
+    */
-	bitfield DOSDate {
+    bitfield DOSDate {
-		day: 5;
+        day: 5;
-		month: 4;
+        month: 4;
-		year: 7;
+        year: 7;
-	} [[sealed]];
+    } [[sealed]];
 
-	/**
+    /**
-		A type to represent a DOS time.
+        A type to represent a DOS time.
-	*/
+    */
-	bitfield DOSTime {
+    bitfield DOSTime {
-		seconds: 5;
+        seconds: 5;
-		minutes: 6;
+        minutes: 6;
-		hours: 5;
+        hours: 5;
-	} [[sealed]];
+    } [[sealed]];
 
-	namespace impl {
+    namespace impl {
 
-		union DOSDateConverter {
+        union DOSDateConverter {
-			DOSDate date;
+            DOSDate date;
-			u16 value;
+            u16 value;
-		};
+        };
 
-		union DOSTimeConverter {
+        union DOSTimeConverter {
-			DOSTime time;
+            DOSTime time;
-			u16 value;
+            u16 value;
-		};
+        };
 
-	}
+    }
 
 
-	/**
+    /**
-		Returns the current time in seconds since the epoch.
+        Returns the current time in seconds since the epoch.
-		@return The current time in seconds since the epoch.
+        @return The current time in seconds since the epoch.
-	*/
+    */
-	fn epoch() {
+    fn epoch() {
-		return builtin::std::time::epoch();
+        return builtin::std::time::epoch();
-	};
+    };
 
-	/**
+    /**
-		Converts a time in seconds since the epoch to a local time.
+        Converts a time in seconds since the epoch to a local time.
-		@param epoch_time The time in seconds since the epoch.
+        @param epoch_time The time in seconds since the epoch.
-		@return The local time.
+        @return The local time.
-	*/
+    */
-	fn to_local(EpochTime epoch_time) {
+    fn to_local(EpochTime epoch_time) {
-		TimeConverter converter;
+        le TimeConverter converter;
 
-		converter.value = builtin::std::time::to_local(epoch_time);
+        converter.value = builtin::std::time::to_local(epoch_time);
 
-		return converter.time;
+        return converter.time;
-	};
+    };
 
-	/**
+    /**
-		Converts a time in seconds since the epoch to a UTC time.
+        Converts a time in seconds since the epoch to a UTC time.
-		@param epoch_time The time in seconds since the epoch.
+        @param epoch_time The time in seconds since the epoch.
-		@return The UTC time.
+        @return The UTC time.
-	*/
+    */
-	fn to_utc(EpochTime epoch_time) {
+    fn to_utc(EpochTime epoch_time) {
-		TimeConverter converter;
+        le TimeConverter converter;
 
-		converter.value = builtin::std::time::to_utc(epoch_time);
+        converter.value = builtin::std::time::to_utc(epoch_time);
 
-		return converter.time;
+        return converter.time;
-	};
+    };
 
-	/**
+    /**
-		Queries the current time in the specified time zone.
+        Queries the current time in the specified time zone.
-		@param time_zone The time zone to query.
+        @param [time_zone] The time zone to query. Defaults to local.
-		@return The current time in the specified time zone.
+        @return The current time in the specified time zone.
-	*/
+    */
-	fn now(TimeZone time_zone = TimeZone::Local) {
+    fn now(TimeZone time_zone = TimeZone::Local) {
-		TimeConverter converter;
+        le TimeConverter converter;
 
-		if (time_zone == TimeZone::Local)
+        if (time_zone == TimeZone::Local)
-			converter.value = builtin::std::time::to_local(std::time::epoch());
+            converter.value = builtin::std::time::to_local(std::time::epoch());
-		else if (time_zone == TimeZone::UTC)
+        else if (time_zone == TimeZone::UTC)
-			converter.value = builtin::std::time::to_utc(std::time::epoch());
+            converter.value = builtin::std::time::to_utc(std::time::epoch());
-		else
+        else
-			converter.value = 0x00;
+            converter.value = 0x00;
 
-		return converter.time;
+        return converter.time;
-	};
+    };
 
-	/**
+    /**
-		Converts a value to a DOS date.
+        Converts a value to a DOS date.
-		@param value The value to convert.
+        @param value The value to convert.
-		@return The DOS date.
+        @return The DOS date.
-	*/
+    */
-	fn to_dos_date(u16 value) {
+    fn to_dos_date(u16 value) {
-		impl::DOSDateConverter converter;
+        le impl::DOSDateConverter converter;
 
-		converter.value = value;
+        converter.value = value;
 
-		return converter.date;
+        return converter.date;
-	};
+    };
 
-	/**
+    /**
-		Converts a value to a DOS time.
+        Converts a value to a DOS time.
-		@param value The value to convert.
+        @param value The value to convert.
-		@return The DOS time.
+        @return The DOS time.
-	*/
+    */
-	fn to_dos_time(u16 value) {
+    fn to_dos_time(u16 value) {
-		impl::DOSTimeConverter converter;
+        le impl::DOSTimeConverter converter;
 
-		converter.value = value;
+        converter.value = value;
 
-		return converter.time;
+        return converter.time;
-	};
+    };
 
-	/**
+    /**
-		Formats a time according to the specified format string.
+        Converts a FILETIME to unix time.
-		@param time The time to format.
+        @param value The value to convert.
-		@param format_string The format string to use.
+        @return Timestamp formatted as unix time.
-		@return The formatted time.
+    */
-	*/
+    fn filetime_to_unix(u64 value) {
-	fn format(Time time, str format_string = "%c") {
+        return value / 10000000 - 11644473600;
-		TimeConverter converter;
+    };
-		converter.time = time;
 
-		return builtin::std::time::format(format_string, converter.value);
+    /**
-	};
+        Formats a time according to the specified format string.
+        @param time The time to format.
+        @param [format_string] The format string to use. Defaults to "%c".
+        @return The formatted time.
+    */
+    fn format(Time time, str format_string = "%c") {
+        le TimeConverter converter;
+        converter.time = time;
 
-	/**
+        return builtin::std::time::format(format_string, converter.value);
-		Formats a DOS date according to the specified format string.
+    };
-		@param date The DOS date to format.
-		@param format_string The format string to use.
-		@return The formatted DOS date.
-	*/
-	fn format_dos_date(DOSDate date, str format_string = "{}/{}/{}") {
-		return std::format(format_string, date.day, date.month, date.year + 1980);
-	};
 
-	/**
+    /**
-		Formats a DOS time according to the specified format string.
+        Formats a DOS date according to the specified format string.
-		@param time The DOS time to format.
+        @param date The DOS date to format.
-		@param format_string The format string to use.
+        @param [format_string] The format string to use. Defaults to "{}/{}/{}".
-		@return The formatted DOS time.
+        @return The formatted DOS date.
-	*/
+    */
-	fn format_dos_time(DOSTime time, str format_string = "{:02}:{:02}:{:02}") {
+    fn format_dos_date(DOSDate date, str format_string = "{}/{}/{}") {
-		return std::format(format_string, time.hours, time.minutes, time.seconds * 2);
+        return std::format(format_string, date.day, date.month, date.year + 1980);
-	};
+    };
+
+    /**
+        Formats a DOS time according to the specified format string.
+        @param time The DOS time to format.
+        @param [format_string] The format string to use. Defaults to "{:02}:{:02}:{:02}".
+        @return The formatted DOS time.
+    */
+    fn format_dos_time(DOSTime time, str format_string = "{:02}:{:02}:{:02}") {
+        return std::format(format_string, time.hours, time.minutes, time.seconds * 2);
+    };
 
 }

includes/type/base.pat

@@ -1,14 +1,14 @@
 #pragma once
 
-#include <std/io.pat>
+import std.io;
-#include <std/math.pat>
+import std.math;
 
 /*!
     Types used to change the base of the displayed integer value.
     Used like `type::Hex<u32> hexNumber;`, `type::Oct<u16> octalNumber;`
 */
 
-namespace type {
+namespace auto type {
     
     /**
         Integer type representing a Hexadecimal value. Displays its value in hexadecimal format.
@@ -34,7 +34,7 @@ namespace type {
     */
     using Bin<T> = T [[format("type::impl::format_bin")]];
 
-	namespace impl {
+    namespace impl {
 
             fn format_number(auto value, str fmt) {
                 bool negative = value < 0;
@@ -50,6 +50,6 @@ namespace type {
             fn format_dec(auto value) { return type::impl::format_number(value, "{}"); };
             fn format_bin(auto value) { return type::impl::format_number(value, "0b{:08b}"); };
 
-	}
+    }
 
 }

includes/type/base64.pat

@@ -1,12 +1,12 @@
-#include <std/io.pat>
+import std.io;
-#include <std/string.pat>
+import std.string;
-#include <std/mem.pat>
+import std.mem;
 
 /*!
     Type representing a Base64 encoded string
 */
 
-namespace type {
+namespace auto type {
 
     /**
         Type representing a Base64 encoded string

includes/type/bcd.pat

@@ -1,12 +1,12 @@
 #pragma once
 
-#include <std/io.pat>
+import std.io;
 
 /*!
     Type to decode a BCD (Binary Coded Decimal) number
 */
 
-namespace type {
+namespace auto type {
 
     /**
         Decodes a BCD value where one byte represents a single digit

includes/type/byte.pat

@@ -1,13 +1,14 @@
 #pragma once
 
-#include <std/io.pat>
+import std.io;
+import std.core;
 
 /*!
     Types to display single bytes using various different representations
 */
 
-namespace type {
+namespace auto type {
-    
+
     /**
         Type visualizing the value of each individual bit
     */
@@ -20,8 +21,8 @@ namespace type {
         bit5 : 1;
         bit6 : 1;
         bit7 : 1;
-    } [[format("type::impl::format_bits"), right_to_left]];
+    } [[format("type::impl::format_bits"), bitfield_order(std::core::BitfieldOrder::LeastToMostSignificant, 8)]];
-    
+
     /**
         Type visualizing the value of the two nibbles
     */
@@ -29,9 +30,9 @@ namespace type {
         low  : 4;
         high : 4;
     } [[format("type::impl::format_nibbles")]];
-    
+
     /**
-        Type representing a single Byte. Decodes the byte as it's hexadeicmal value, individual bits and nibbles
+        Type representing a single Byte. Decodes the byte as it's hexadecimal value, individual bits and nibbles
     */
     union Byte {
         u8 value;
@@ -40,7 +41,7 @@ namespace type {
     } [[format("type::impl::format_byte"), single_color]];
 
 
-	namespace impl {
+    namespace impl {
 
         fn format_byte(Byte byte) {
             return std::format("0x{0:02X} (0b{1:08b}) LSB:{2}, MSB:{3}",
@@ -49,9 +50,9 @@ namespace type {
                 byte.bits.bit0,
                 byte.bits.bit7);
         };
-        
+
         fn format_bits(Bits bits) {
-            return std::format("0b{}{}{}{}{}{}{}{}", 
+            return std::format("0b{}{}{}{}{}{}{}{}",
                 bits.bit7,
                 bits.bit6,
                 bits.bit5,
@@ -61,11 +62,11 @@ namespace type {
                 bits.bit1,
                 bits.bit0);
         };
-        
+
         fn format_nibbles(Nibbles nibbles) {
             return std::format("{{ {0:0X}, {1:0X} }}", nibbles.high, nibbles.low);
         };
 
-	}
+    }
 
 }

includes/type/color.pat

@@ -1,28 +1,28 @@
 #pragma once
 
-#include <std/io.pat>
+import std.io;
-#include <std/core.pat>
+import std.core;
 
 /*!
     Types representing RGB or RGBA colors. The decoded color will be displayed in their color field
 */
 
-namespace type {
+namespace auto type {
 
     /**
         Type representing a generic RGBA color with a variable number of bits for each color
         @tparam R Number of bits used for the red component
         @tparam G Number of bits used for the green component
         @tparam B Number of bits used for the blue component
-        @tparam A Number of bits used for the alpha component 
+        @tparam A Number of bits used for the alpha component
     */
     bitfield RGBA<auto R, auto G, auto B, auto A> {
         r : R;
         g : G;
         b : B;
         if (A > 0) a : A;
-    } [[sealed, format("type::impl::format_color"), color(std::format("{0:02X}{1:02X}{2:02X}FF", r, g, b))]];
+    } [[sealed, format("type::impl::format_color"), color(std::format("{0:02X}{1:02X}{2:02X}", r, g, b))]];
-    
+
     /**
         Type representing a generic RGB color with a variable number of bits for each color
         @tparam R Number of bits used for the red component
@@ -30,7 +30,7 @@ namespace type {
         @tparam B Number of bits used for the blue component
     */
     using RGB<auto R, auto G, auto B> = RGBA<R,G,B,0>;
-    
+
 
     /**
         Type representing a RGBA color with 8 bits for the red component, 8 bits for green, 8 bits for blue and 8 bits for alpha
@@ -56,7 +56,7 @@ namespace type {
         Type representing a RGBA color with 5 bits for the red component, 5 bits for green, 5 bits for blue and 1 bits for alpha
     */
     using RGBA5551 = RGBA<5,5,5,1>;
-    
+
 
     namespace impl {
 
@@ -76,5 +76,5 @@ namespace type {
         };
 
     }
-    
+
-}
+}

includes/type/float16.pat

@@ -1,45 +1,45 @@
 #pragma once
 
-#include <std/io.pat>
+import std.io;
-#include <std/math.pat>
+import std.math;
-#include <std/mem.pat>
+import std.mem;
 
 /*!
     Type representing a 16 bit half precision floating point number
 */
 
-namespace type {
+namespace auto type {
-    
+
     /**
         Type representing a 16 bit half precision floating point number
     */
     using float16 = u16 [[format("type::impl::format_float16")]];
 
     namespace impl {
-    
+
         union U32ToFloatConverter {
             u32 intValue;
             float floatValue;
         };
 
-        fn format_float16(float16 value) {	
+        fn format_float16(float16 value) {
             u32 sign = value >> 15;
             u32 exponent = (value >> 10) & 0x1F;
             u32 mantissa = value & 0x3FF;
-    
+
             u32 result = 0x00;
-    
+
             if (exponent == 0) {
                 if (mantissa == 0) {
                     result = sign << 31;
                 } else {
                     exponent = 0x7F - 14;
-    
+
                     while ((mantissa & (1 << 10)) == 0) {
                         exponent -= 1;
                         mantissa <<= 1;
                     }
-    
+
                     mantissa &= 0x3FF;
                     result = (sign << 31) | (exponent << 23) | (mantissa << 13);
                 }
@@ -48,11 +48,11 @@ namespace type {
             } else {
                 result = (sign << 31) | ((exponent + (0x7F - 15)) << 23) | (mantissa << 13);
             }
-            
+
             std::mem::Reinterpreter<u32, float> converter;
-            converter.from = result;
+            converter.from_value = result;
-            
+
-            return std::format("{}", converter.to);
+            return std::format("{}", converter.to_value);
         };
 
     }

includes/type/fmt.pat

@@ -0,0 +1,42 @@
+#pragma once
+
+import std.io;
+
+/*!
+    Type that allows specifying its format value using a format string.
+    ## Usage
+
+    The following code reads a u32 from the data and formats it as an upper case hexadecimal value with
+    a minimum of 8 digits which is prefixed by 0x.
+
+    The format string is the same as passed to `std::format()` and follows the libfmt specification.
+
+    ```rust
+        type::Formatted<u32, "0x{:08X}"> hex_formatted_integer @ 0x00;
+    ```
+*/
+
+namespace auto type {
+
+    /**
+        Arbitrarily formatted type
+        @tparam T Type to format
+        @tparam FormatString libfmt format string to format the value
+    */
+    struct Formatted<T, auto FormatString> {
+        T value;
+    } [[sealed, format("type::impl::format_formatted"), transform("type::impl::transform_formatted")]];
+
+    namespace impl {
+
+        fn format_formatted(ref auto formatted) {
+            return std::format(formatted.FormatString, formatted.value);
+        };
+
+        fn transform_formatted(ref auto formatted) {
+            return formatted.value;
+        };
+
+    }
+
+}

includes/type/guid.pat

@@ -1,17 +1,17 @@
 #pragma once
 
-#include <std/io.pat>
+import std.io;
 
 /*!
-	Types to deal with UUIDs (Universally Unique Identifiers) / GUIDs (Globally Unique Identifiers) as described in RFC 4122
+    Types to deal with UUIDs (Universally Unique Identifiers) / GUIDs (Globally Unique Identifiers) as described in RFC 4122
 */
 
-namespace type {
+namespace auto type {
 
-	/**
+    /**
-		Type representing a GUID value
+        Type representing a GUID value
-	*/
+    */
-	struct GUID {
+    struct GUID {
         u32 time_low;
         u16 time_mid;
         u16 time_high_and_version;
@@ -20,31 +20,31 @@ namespace type {
         u8 node[6];
     } [[sealed, format("type::impl::format_guid")]];
 
-	/**
+    /**
-		Alias name for GUID
+        Alias name for GUID
-	*/
+    */
-	using UUID = GUID;
+    using UUID = GUID;
 
-	namespace impl {
+    namespace impl {
 
-		fn format_guid(GUID guid) {
+        fn format_guid(GUID guid) {
-	        bool valid = ((le u16(guid.time_high_and_version) >> 12) <= 5) && (((guid.clock_seq_and_reserved >> 4) >= 8) || ((guid.clock_seq_and_reserved >> 4) == 0));
+            bool valid = ((le u16(guid.time_high_and_version) >> 12) <= 5) && (((guid.clock_seq_and_reserved >> 4) >= 8) || ((guid.clock_seq_and_reserved >> 4) == 0));
-	
-	        return std::format("{}{{{:08X}-{:04X}-{:04X}-{:02X}{:02X}-{:02X}{:02X}{:02X}{:02X}{:02X}{:02X}}}",
-	            valid ? "" : "Invalid ",
-	            le u32(guid.time_low),
-	            le u16(guid.time_mid),
-	            le u16(guid.time_high_and_version),
-	            guid.clock_seq_and_reserved,
-	            guid.clock_seq_low,
-	            guid.node[0],
-	            guid.node[1],
-	            guid.node[2],
-	            guid.node[3],
-	            guid.node[4],
-	            guid.node[5]);
-	    };
 
-	}
+            return std::format("{}{{{:08X}-{:04X}-{:04X}-{:02X}{:02X}-{:02X}{:02X}{:02X}{:02X}{:02X}{:02X}}}",
+                valid ? "" : "Invalid ",
+                le u32(guid.time_low),
+                le u16(guid.time_mid),
+                le u16(guid.time_high_and_version),
+                guid.clock_seq_and_reserved,
+                guid.clock_seq_low,
+                guid.node[0],
+                guid.node[1],
+                guid.node[2],
+                guid.node[3],
+                guid.node[4],
+                guid.node[5]);
+        };
+
+    }
 
 }

includes/type/ip.pat

@@ -1,13 +1,13 @@
 #pragma once
 
-#include <std/io.pat>
+import std.io;
-#include <std/string.pat>
+import std.string;
 
 /*!
     Types used to decode IP addresses
 */
 
-namespace type {
+namespace auto type {
 
     /**
         A 4 byte IPv4 Address as described in RFC 791

includes/type/leb128.pat

@@ -1,72 +1,72 @@
 #pragma once
 
-#include <std/io.pat>
+import std.io;
-#include <std/mem.pat>
+import std.mem;
 
 /*!
-	Types used to decode Little Endian Base 128 numbers used to store large numbers as space efficiently as possible
+    Types used to decode Little Endian Base 128 numbers used to store large numbers as space efficiently as possible
 */
 
-namespace type {
+namespace auto type {
-	
-	/**
-		Base LEB128 type. Use `uLEB128` and `sLEB128` instead.
-	*/
-	struct LEB128Base {
-		u8 array[while($ == addressof(this) || std::mem::read_unsigned($-1, 1) & 0x80 != 0)] [[hidden]];
-	} [[sealed]];
 
-	/**
+    /**
-		A unsigned variant of a LEB128 number
+        Base LEB128 type. Use `uLEB128` and `sLEB128` instead.
-	*/
+    */
-	using uLEB128 = LEB128Base [[format("type::impl::format_uleb128"), transform("type::impl::transform_uleb128")]];
+    struct LEB128Base {
+        u8 array[while($ == addressof(this) || std::mem::read_unsigned($-1, 1) & 0x80 != 0)] [[hidden]];
+    } [[sealed]];
 
-	/**
+    /**
-		A signed variant of a LEB128 number
+        A unsigned variant of a LEB128 number
-	*/
+    */
-	using sLEB128 = LEB128Base [[format("type::impl::format_sleb128"), transform("type::impl::transform_sleb128")]];
+    using uLEB128 = LEB128Base [[format("type::impl::format_uleb128"), transform("type::impl::transform_uleb128")]];
 
-	/**
+    /**
-		Legacy alias for uLEB128
+        A signed variant of a LEB128 number
-	*/
+    */
-	using LEB128 = uLEB128;
+    using sLEB128 = LEB128Base [[format("type::impl::format_sleb128"), transform("type::impl::transform_sleb128")]];
-	
-	namespace impl {
-	
-		fn transform_uleb128_array(ref auto array) {
-			u128 res = array[0] & 0x7f;
-			for(u8 i = 1, array[i-1] & 0x80 != 0, i+=1) {
-				res |= u128(array[i] & 0x7f) << 7 * i;
-			}
-			return res;
-		};
 
-		fn transform_sleb128_array(ref auto array) {			
+    /**
-			s128 res = type::impl::transform_uleb128_array(array);
+        Legacy alias for uLEB128
-			if (res & 0x40 != 0) {
+    */
-				res |= ~0 << (sizeof(array) / sizeof(u8)) * 7;
+    using LEB128 = uLEB128;
-			}
-			return res;
-		};
-		
-		fn format_uleb128(ref auto leb128) {
-			u128 res = type::impl::transform_uleb128_array(leb128.array);
-			return std::format("{} ({:#x})", res, res);
-		};
-	
-		fn transform_uleb128(ref auto leb128) {
-			return type::impl::transform_uleb128_array(leb128.array);
-		};
 
-		fn format_sleb128(ref auto leb128) {
+    namespace impl {
-			s128 res = type::impl::transform_sleb128_array(leb128.array);
+
-			return std::format("{} ({:#x})", res, res);
+        fn transform_uleb128_array(ref auto array) {
-		};
+            u128 res = array[0] & 0x7f;
-	
+            for(u8 i = 1, array[i-1] & 0x80 != 0, i+=1) {
-		fn transform_sleb128(ref auto leb128) {
+                res |= u128(array[i] & 0x7f) << 7 * i;
-			return type::impl::transform_sleb128_array(leb128.array);
+            }
-		};
+            return res;
+        };
+
+        fn transform_sleb128_array(ref auto array) {
+            s128 res = type::impl::transform_uleb128_array(array);
+            if (res & 1 << ((sizeof(array) / sizeof(u8)) * 7 - 1) != 0) {
+                res |= ~0 << (sizeof(array) / sizeof(u8)) * 7;
+            }
+            return res;
+        };
+
+        fn format_uleb128(ref auto leb128) {
+            u128 res = type::impl::transform_uleb128_array(leb128.array);
+            return std::format("{} ({:#x})", res, res);
+        };
+
+        fn transform_uleb128(ref auto leb128) {
+            return type::impl::transform_uleb128_array(leb128.array);
+        };
+
+        fn format_sleb128(ref auto leb128) {
+            s128 res = type::impl::transform_sleb128_array(leb128.array);
+            return std::format("{} ({:#x})", res, res);
+        };
+
+        fn transform_sleb128(ref auto leb128) {
+            return type::impl::transform_sleb128_array(leb128.array);
+        };
+
+    }
 
-	}
-	
 }

includes/type/mac.pat

@@ -1,32 +1,32 @@
 #pragma once
 
-#include <std/io.pat>
+import std.io;
 
 /*!
-	Types used to decode MAC Addresses
+    Types used to decode MAC Addresses
 */
 
-namespace type {
+namespace auto type {
 
-	/**
+    /**
-		A MAC Address as used in the Internet Protocol
+        A MAC Address as used in the Internet Protocol
-	*/
+    */
-	struct MACAddress {
+    struct MACAddress {
-		u8 bytes[6];
+        u8 bytes[6];
-	} [[sealed, format("type::impl::format_mac_address")]];
+    } [[sealed, format("type::impl::format_mac_address")]];
 
-	namespace impl {
+    namespace impl {
 
         fn format_mac_address(MACAddress address) {
-			return std::format("{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}",
+            return std::format("{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}",
-				address.bytes[0],
+                address.bytes[0],
-				address.bytes[1],
+                address.bytes[1],
-				address.bytes[2],
+                address.bytes[2],
-				address.bytes[3],
+                address.bytes[3],
-				address.bytes[4],
+                address.bytes[4],
-				address.bytes[5]);
+                address.bytes[5]);
-		};
+        };
 
-	}
+    }
 
 }

includes/type/magic.pat

@@ -1,13 +1,33 @@
-#include <std/string.pat>
+import std.string;
-#include <std/sys.pat>
+import std.sys;
-#include <std/io.pat>
+import std.io;
-#include <std/ctype.pat>
+import std.ctype;
 
 /*!
     Types used to parse and enforce specific magic numbers
 */
 
-namespace type {
+namespace auto type
+{
+
+    /**
+        Escapes all bytes in a string to only contain printable characters. All non-printable bytes will be transformed to sequences in the \xFF form
+        @param value Byte array to escape
+        @return Escaped string
+    */
+    fn escape_bytes(ref auto value) {
+        str result;
+        for (u32 i = 0, i < sizeof(value), i += 1)
+        {
+            char c = value[i];
+
+            if (std::ctype::isprint(c))
+                result += c;
+            else
+                result += std::format("\\x{:02X}", u8(c));
+        }
+        return result;
+    };
 
     /**
         A Magic number. Throws an error if the magic number does not match the expected value
@@ -15,24 +35,11 @@ namespace type {
     */
     struct Magic<auto ExpectedValue> {
         char value[std::string::length(ExpectedValue)];
-        std::assert(value == ExpectedValue, std::format("Invalid magic value! Expected \"{}\", got \"{}\".", ExpectedValue, value));
+        std::assert(value == ExpectedValue, std::format("Invalid magic value! Expected \"{}\", got \"{}\" at position 0x{:X}", type::escape_bytes(ExpectedValue), type::escape_bytes(value), $ - std::string::length(ExpectedValue)));
     } [[sealed, format("type::impl::format_magic")]];
-    
     namespace impl {
-    
         fn format_magic(ref auto magic) {
-            str result;
+            return std::format("\"{}\"", type::escape_bytes(magic.value));
-            for (u32 i = 0, i < sizeof(magic.value), i += 1) {
-                char c = magic.value[i];
-
-                if (std::ctype::isprint(c))
-                    result += c;
-                else
-                    result += std::format("\\x{:02X}", u8(c));
-            }
-            return std::format("\"{}\"", result);
         };
-        
     }
-
 }

includes/type/path.pat

@@ -1,53 +1,53 @@
-#include <std/mem.pat>
+import std.mem;
 
 /*!
-	Types dealing with various kinds of resource paths
+    Types dealing with various kinds of resource paths
 */
 
-namespace type {
+namespace auto type {
 
-	/**
+    /**
-		Type representing a single path segment. Use the `Path` type instead of using this on its own
+        Type representing a single path segment. Use the `Path` type instead of using this on its own
-		@tparam Delimeter The delimeter sequence used to separate two path segments
+        @tparam Delimiter The delimiter sequence used to separate two path segments
-	*/
+    */
-	struct PathSegment<auto Delimeter> {
+    struct PathSegment<auto Delimiter> {
-		char string[while(std::mem::read_string($, std::string::length(Delimeter)) != Delimeter && std::mem::read_unsigned($, 1) != 0x00)];
+        char string[while(std::mem::read_string($, std::string::length(Delimiter)) != Delimiter && std::mem::read_unsigned($, 1) != 0x00)];
-		char separator [[hidden]];
+        char separator [[hidden]];
-		
+        
-		if (separator == 0x00) {
+        if (separator == 0x00) {
-			$ -= 1;
+            $ -= 1;
-			break;
+            break;
-		}
+        }
-	} [[sealed, format("type::impl::format_path_segment")]];
+    } [[sealed, format("type::impl::format_path_segment")]];
-	
+    
-	/**
+    /**
-		A generic type representing a path with an arbitrary delimeter
+        A generic type representing a path with an arbitrary delimiter
-		@tparam Delimeter The delimeter sequence used to separate two path segments
+        @tparam Delimiter The delimiter sequence used to separate two path segments
-	*/
+    */
-	struct Path<auto Delimeter> {
+    struct Path<auto Delimiter> {
-		PathSegment<Delimeter> segments[while(true)];
+        PathSegment<Delimiter> segments[while(true)];
-	} [[format("type::impl::format_path")]];
+    } [[format("type::impl::format_path")]];
-	
+    
-	/**
+    /**
-		A type representing a Unix path using a '/' forwardslash as delimeter
+        A type representing a Unix path using a '/' forward slash as delimiter
-	*/
+    */
-	using UnixPath = Path<"/">;
+    using UnixPath = Path<"/">;
 
-	/**
+    /**
-		A type representing a DOS path using a '\' backslash as delimeter
+        A type representing a DOS path using a '\\' backslash as delimiter
-	*/
+    */
-	using DOSPath = Path<"\\">;
+    using DOSPath = Path<"\\">;
-	
+
-	namespace impl {
+    namespace impl {
-	
+
-		fn format_path_segment(ref auto segment) {
+        fn format_path_segment(ref auto segment) {
-			return segment.string;
+            return segment.string;
-		};
+        };
-	
+    
-		fn format_path(ref auto path) {
+        fn format_path(ref auto path) {
-			return std::mem::read_string($, sizeof(path));
+            return std::mem::read_string($, sizeof(path));
-		};
+        };
-	
+    
-	}
+    }
 
 }

includes/type/size.pat

@@ -1,10 +1,10 @@
-#include <std/io.pat>
+import std.io;
 
 /*!
     Types used to pretty print size values
 */
 
-namespace type {
+namespace auto type {
 
     /**
         A generic size type which displays its value in Bytes (or kiB, MiB, GiB, TiB, PiB, EiB if larger)

includes/type/time.pat

@@ -1,21 +1,21 @@
 #pragma once
 
-#include <std/io.pat>
+import std.io;
-#include <std/time.pat>
+import std.time;
 
 /*!
     Types used to decode various different time formats
 */
 
-namespace type {
+namespace auto type {
 
     /**
         A 32 bit Unix time value
     */
     using time32_t = u32 [[format("type::impl::format_time_t")]];
-    
+
     /**
-        Alias name for `time32_t` 
+        Alias name for `time32_t`
     */
     using time_t = time32_t;
 
@@ -34,6 +34,11 @@ namespace type {
     */
     using DOSTime = u16 [[format("type::impl::format_dostime")]];
 
+    /**
+        A 64bit FILETIME value
+    */
+    using FILETIME = u64 [[format("type::impl::format_filetime_as_unix")]];
+
     namespace impl {
 
         fn format_time_t(u128 value) {
@@ -48,6 +53,10 @@ namespace type {
             return std::time::format_dos_time(std::time::to_dos_time(value));
         };
 
+        fn format_filetime_as_unix(u64 value) {
+            return std::time::filetime_to_unix(value);
+        };
+
     }
 
 }

includes/type/types/010.pat

@@ -5,7 +5,7 @@
 */
 
 // Explicitly don't add these types to the `type` namespace for usability
-// namespace type {
+// namespace auto type {
 
     // using char   = s8;
     using byte      = s8;

includes/type/types/c.pat

@@ -5,7 +5,7 @@
 */
 
 // Explicitly don't add these types to the `type` namespace for usability
-// namespace type {
+// namespace auto type {
 
     using uint8_t       = u8;
     using uint16_t      = u16;

includes/type/types/linux.pat

@@ -5,7 +5,7 @@
 */
 
 // Explicitly don't add these types to the `type` namespace for usability
-// namespace type {
+// namespace auto type {
 
     using le16  = le u16;
     using be16  = be u16;

includes/type/types/rust.pat

@@ -5,7 +5,7 @@
 */
 
 // Explicitly don't add these types to the `type` namespace for usability
-// namespace type {
+// namespace auto type {
 
     // using u8        = u8;
     // using u16       = u16;

includes/type/types/win32.pat

@@ -5,7 +5,7 @@
 */
 
 // Explicitly don't add these types to the `type` namespace for usability
-// namespace type {
+// namespace auto type {
 
     using BYTE      = u8;
     using WORD      = u16;

magic/portable_executable_magic

@@ -1,4 +1,4 @@
-# A libmagic database containing definition for PE files used by MS-DOS based systems
+# A libmagic database containing definition for PE files used by MS-DOS/Windows based systems
 
 # MS-DOS Portable Executable
 0x0		    string/b	MZ      MS-DOS Binary

patterns/7z.hexpat

@@ -1,99 +1,93 @@
-#include <std/io.pat> 
+#pragma description 7z Archive
-#include <std/mem.pat> 
+#pragma MIME application/x-7z-compressed
-#include <std/math.pat> 
+#pragma magic [ 37 7A BC AF 27 1C ] @ 0x00
+
+import std.io;
+import std.mem;
+import std.math;
+import type.magic;
 
 
-enum Type:u8{ 
+enum Type:u8{
-    startPosition = 0x00,       // Start position 
+    startPosition = 0x00,       // Start position
-    sizeStartHeader = 0x20,  // Size of start Header       
+    sizeStartHeader = 0x20,  // Size of start Header
-}; 
+};
 
-enum TypeB:u48{ 
+struct StartHeader {
-    sevenZipSignature = 0x1C27AFBC7A37,  // Defining 7z signature   
+    // File signature
-};   
+    type::Magic<"7z\xBC\xAF\x27\x1C"> signature  [[color("FF0000")] ];
+    // Version format
+    u16 formatVersion [[color("00FF00")]];
+    // CRC start header
+    u32 crcOfTheFollowing20Bytes [[color("0000FF")]];
+    // Relative offset of End Header
+    u64 relativeOffsetEndHeader [[color("FFFF00")]];
+    // Length of End Header
+    u64 theLengthOfEndHeader [[color("00FFFF")]];
+    // CRC of End Ender
+    u32 crcOftheEndHeader [[color("FF00FF")]];
+    // File size calculation
+    u64 fileSize = relativeOffsetEndHeader + theLengthOfEndHeader + Type::sizeStartHeader;
+    // Absolute offset calculation End Header
+    u64 startEndHeader = relativeOffsetEndHeader +  Type::sizeStartHeader;
+};
 
-struct StartHeader { 
+StartHeader startheader @ Type::startPosition;
-    // File signature 
-    u48 signature  [[color("FF0000")] ];  
-    // Version format 
-    u16 formatVersion [[color("00FF00")]];  
-    // CRC start header 
-    u32 crcOfTheFollowing20Bytes [[color("0000FF")]]; 
-    // Relative offset of End Header 
-    u64 relativeOffsetEndHeader [[color("FFFF00")]]; 
-    // Length of End Header 
-    u64 theLengthOfEndHeader [[color("00FFFF")]];  
-    // CRC of End Ender 
-    u32 crcOftheEndHeader [[color("FF00FF")]]; 
-    // File size calculation 
-    u64 fileSize = relativeOffsetEndHeader + theLengthOfEndHeader + Type::sizeStartHeader; 
-    // Absolute offset calculation End Header 
-    u64 startEndHeader = relativeOffsetEndHeader +  Type::sizeStartHeader; 
-}; 
 
-StartHeader startheader @ Type::startPosition; 
+struct CompressedData {
- 
+     // Start of compressed data
-struct CompressedData { 
+     u8 startOfCompressedData[4] [[color("C0C0C0")]];
-     // Start of compressed data     
+};
-     u8 startOfCompressedData[4] [[color("C0C0C0")]];          
-}; 
 
-CompressedData compresseddata @ Type::sizeStartHeader; 
+CompressedData compresseddata @ Type::sizeStartHeader;
 
-  
-struct EndHeader { 
-    // Set padding to place End Header in right position 
-    padding[startheader.relativeOffsetEndHeader]; 
-    // Mark link to meta block 
-    u8 linkToMetaBlock [[color("FF0000")]];     
-    // Mark all End Header 
-    char fullEndHeader[startheader.theLengthOfEndHeader] [[color("63954A")]];  
-    // Detect LZMA signature 
-    u64 lzmaSignaturePosition = std::mem::find_sequence_in_range(0, addressof(fullEndHeader), addressof(fullEndHeader) + sizeof(fullEndHeader), 0x23, 0x03, 0x01, 0x01, 0x05, 0x5D);    
-                                                 
-    // Mark positions if LZMA signature was detected 
-    if(lzmaSignaturePosition != 0xFFFFFFFFFFFFFFFF){ 
-        u48 lzmaSignature @ lzmaSignaturePosition [[color("0000FF")]];   
-    } 
-}; 
 
-EndHeader endheader @ Type::sizeStartHeader; 
+struct EndHeader {
- 
+    // Set padding to place End Header in right position
-// Check 7z type 
+    padding[startheader.relativeOffsetEndHeader];
-if(startheader.signature ==  TypeB::sevenZipSignature){ 
+    // Mark link to meta block
-    std::print("It is a 7z File Type");  
+    u8 linkToMetaBlock [[color("FF0000")]];
-}else{ 
+    // Mark all End Header
-    std::print("The file is not 7z type");  
+    char fullEndHeader[startheader.theLengthOfEndHeader] [[color("63954A")]];
-}  
+    // Detect LZMA signature
+    u64 lzmaSignaturePosition = std::mem::find_sequence_in_range(0, addressof(fullEndHeader), addressof(fullEndHeader) + sizeof(fullEndHeader), 0x23, 0x03, 0x01, 0x01, 0x05, 0x5D);
 
-std::print("Format Version {} ",startheader.formatVersion);  
+    // Mark positions if LZMA signature was detected
+    if(lzmaSignaturePosition != 0xFFFFFFFFFFFFFFFF){
+        u48 lzmaSignature @ lzmaSignaturePosition [[color("0000FF")]];
+    }
+};
 
-// Version verification 
+EndHeader endheader @ Type::sizeStartHeader;
-if(startheader.formatVersion ==  0x0400){ 
-    std::print("Major Version 0x00 || 0 -  Minor Version 0x04 || 4");  
-}    
 
-// Verification of the compressed method is LZMA, Bzip2 or LZMA2 
+std::print("Format Version {} ",startheader.formatVersion);
-if(compresseddata.startOfCompressedData[0] ==  Type::startPosition){  
-     std::print("Compressed Method LZMA");    
-}else if(compresseddata.startOfCompressedData[0] ==  0x42){  
-    std::print("Compressed Method Bzip2");    
-}else{  
-    std::print("Compressed Method LZMA2");    
-} 
 
-  
+// Version verification
+if(startheader.formatVersion ==  0x0400){
+    std::print("Major Version 0x00 || 0 -  Minor Version 0x04 || 4");
+}
 
-std::print("CRC Start Header 0x{:X}",startheader.crcOfTheFollowing20Bytes);     
+// Verification of the compressed method is LZMA, Bzip2 or LZMA2
+if(compresseddata.startOfCompressedData[0] ==  Type::startPosition){
+     std::print("Compressed Method LZMA");
+}else if(compresseddata.startOfCompressedData[0] ==  0x42){
+    std::print("Compressed Method Bzip2");
+}else{
+    std::print("Compressed Method LZMA2");
+}
 
-std::print("CRC End Header 0x{:X} ", startheader.crcOftheEndHeader);  
 
-std::print("CompressedData length 0x{:X} || {} bytes ",startheader.relativeOffsetEndHeader, startheader.relativeOffsetEndHeader);  
 
-std::print("Relative Offset of End Header 0x{:X} || {} bytes",startheader.relativeOffsetEndHeader, startheader.relativeOffsetEndHeader);  
+std::print("CRC Start Header 0x{:X}",startheader.crcOfTheFollowing20Bytes);
 
-std::print("Offset to start End Header 0x{:X} || {} bytes",startheader.startEndHeader,startheader.startEndHeader);  
+std::print("CRC End Header 0x{:X} ", startheader.crcOftheEndHeader);
 
-std::print("End Header length 0x{:X} || {} bytes",startheader.theLengthOfEndHeader,startheader.theLengthOfEndHeader);  
+std::print("CompressedData length 0x{:X} || {} bytes ",startheader.relativeOffsetEndHeader, startheader.relativeOffsetEndHeader);
 
-std::print("File size 0x{:X} || {} bytes",startheader.fileSize, startheader.fileSize); 
+std::print("Relative Offset of End Header 0x{:X} || {} bytes",startheader.relativeOffsetEndHeader, startheader.relativeOffsetEndHeader);
+
+std::print("Offset to start End Header 0x{:X} || {} bytes",startheader.startEndHeader,startheader.startEndHeader);
+
+std::print("End Header length 0x{:X} || {} bytes",startheader.theLengthOfEndHeader,startheader.theLengthOfEndHeader);
+
+std::print("File size 0x{:X} || {} bytes",startheader.fileSize, startheader.fileSize);

patterns/Crashlvl.hexpat

@@ -1,18 +1,28 @@
-#include <type/magic.pat>
+#pragma author AdventureT
-#include <std/string.pat>
+#pragma description Crash Bandicoot - Back in Time (fan game) User created level
-#include <std/array.pat>
+#pragma magic [ 43 52 41 53 48 4C 56 4C ] @ 0x00
+#pragma history
+#pragma   0.3  2024-05-15 Added support for version 0.95
+#pragma   0.2  2023-10-29 Added support for version 0.94c
+#pragma   0.1  2023-04-25 Initial support
+// Supports all versions till 0.95, newer versions might be compatible!
 
-// Crash Bandicoot - Back in Time (fan game) user created tapes
+import type.magic;
-// author AdventureT
+import std.string;
+import std.array;
 
 struct Header {
     type::Magic<"CRASHLVL"> magic;
     u8 version;
+    if (version >= 4) {
+        std::string::SizedString<u8> gameVersion;
+    }
     std::string::SizedString<u8> levelName;
     std::string::SizedString<u8> author;
 };
 
-enum Music : u32 {
+// Background Music
+enum BGM : u32 {
     None,
     BonusBGM,
     CrashCreatorBGM,
@@ -28,39 +38,327 @@ enum Music : u32 {
     NBrioBGM
 };
 
+enum BGMV2 : u32 {
+    None,
+    N_TropyBGM,
+    CrashCreatorBGM,
+    MainMenuBGM,
+    WarpRoomBGM,
+    Jungle01BGM,
+    SnowBGM,
+    RiverBGM,
+    FutureBGM,
+    LabBGM,
+    SewerBGM,
+    EgyptBGM,
+    NBrioBGM,
+    AdventureBGM,
+    SpyBGM,
+    ChaseBGM,
+    TrialsBGM,
+    SpaceBGM,
+    Jungle02BGM,
+    RipperBGM,
+    TheGreatWallBGM,
+    RoadToSomewhereBGM,
+    LavaKoalaBGM,
+    CortexBGM,
+    CyberCortexBGM,
+    ArabicBGM,
+    N_Tropy2BGM,
+    JazzBGM,
+    Space2BGM,
+    TawnaBonusBGM,
+    CortexPowerBGM,
+    ArabicBonusBGM,
+    EgyptBonusBGM,
+    FutureBonusBGM,
+    LostCityBGM,
+    PolarBGM,
+    RiverBonusBGM,
+    RuinsBonusBGM,
+    SewerBonusBGM,
+    SnowBonusBGM,
+    RoadToRuinBGM,
+    NGinBGM,
+    Arabia01BGM,
+    Arabia02BGM,
+    BashBGM,
+    Cortex02BGM
+};
+
+// v0.95
+enum BGMV3 : BGMV2 {
+    None,
+    N_TropyBGM,
+    CrashCreatorBGM,
+    MainMenuBGM,
+    WarpRoomBGM,
+    Jungle01BGM,
+    SnowBGM,
+    RiverBGM,
+    FutureBGM,
+    LabBGM,
+    SewerBGM,
+    EgyptBGM,
+    NBrioBGM,
+    AdventureBGM,
+    SpyBGM,
+    ChaseBGM,
+    TrialsBGM,
+    SpaceBGM,
+    Jungle02BGM,
+    RipperBGM,
+    TheGreatWallBGM,
+    RoadToSomewhereBGM,
+    LavaKoalaBGM,
+    CortexBGM,
+    CyberCortexBGM,
+    ArabicBGM,
+    N_Tropy2BGM,
+    JazzBGM,
+    Space2BGM,
+    TawnaBonusBGM,
+    CortexPowerBGM,
+    ArabicBonusBGM,
+    EgyptBonusBGM,
+    FutureBonusBGM,
+    LostCityBGM,
+    PolarBGM,
+    RiverBonusBGM,
+    RuinsBonusBGM,
+    SewerBonusBGM,
+    SnowBonusBGM,
+    RoadToRuinBGM,
+    NGinBGM,
+    Arabia01BGM,
+    Arabia02BGM,
+    BashBGM,
+    Cortex02BGM,
+    MedievalBGM,
+    PreHistoricBGM,
+    UnderWaterBGM,
+    BrioRevisitedBGM,
+    EgyptChaseBGM,
+    RuinsLoopBGM,
+    DingoSynthBGM
+};
+
 enum Type : u32 {
     Unset,
     Flashback,
     Trial
 };
 
-enum Time : u32 {
+enum TypeV2 : u32 {
+    Practice,
+    Flashback,
+    Trial,
+    Adventure
+};
+
+enum Skybox : u32 {
     Night,
     Day,
     Storm,
     Dawn
 };
 
-enum Terrain : u32 {
+enum SkyboxV2 : u32 {
+    Default = 1,
+    Briolab,
+    Fort,
+    Moon,
+    Toxic,
+    AboutRight,
+    Crash1Island,
+    Arabia,
+    RoadToRuin,
+    Black
+};
+
+// 0.95
+enum SkyboxV3 : u32 {
+    Default = 1,
+    Briolab,
+    Fort,
+    Moon,
+    Toxic,
+    AboutRight,
+    Crash1Island,
+    Arabia,
+    RoadToRuin,
+    MotorcycleDay,
+    MotorcycleNoon,
+    MotorcycleMoon,
+    MotorcycleNight,
+    Black
+};
+
+enum Scenery : u32 {
     None,
-    Machines,
+    FutureTense,
-    Trees,
+    Forest,
+    Waterfall,
+    Snow,
+    Fortress
+};
+
+enum SceneryV2 : u32 {
+    None,
+    FutureTense,
+    Forest,
+    Waterfall,
+    None2,
+    Fortress,
+    None3,
+    Lava,
+    TheGreatGate,
+    Mountain,
+    KoalaKong,
+    SunsetVista,
+    HangemHigh,
+    Sphynxinator,
+    Tunnel,
+    Pipes
+};
+
+enum SceneryV4 : u32 {
+    None,
+    FutureTense,
+    Forest,
     Waterfall,
     Snow,
     Fortress,
+    None2,
+    Lava,
+    TheGreatGate,
+    Mountain,
+    KoalaKong,
+    SunsetVista,
+    HangemHigh,
+    Sphynxinator,
+    Tunnel,
+    Pipes
 };
 
+// 0.95
+enum SceneryV5 : u32 {
+    None,
+    FutureTense,
+    Forest,
+    Waterfall,
+    Snow,
+    Fortress,
+    None2,
+    Lava,
+    TheGreatGate,
+    Mountain,
+    KoalaKong,
+    SunsetVista,
+    HangemHigh,
+    Sphynxinator,
+    Tunnel,
+    Pipes,
+    Medieval,
+    FutureCity,
+    TinyArena,
+    HeavyMachinery,
+    CrystalCave,
+    MedievalWithHouses,
+    CortexBonusChamber
+};
+
+enum Weather : u32 {
+    Default,
+    Snow,
+    Rain
+};
+
+// 0.95
+enum WeatherV2 : u32 {
+    Default,
+    Snow,
+    Rain,
+    Night,
+    UnderWater
+};
+
+
 struct Options {
-    Type type;
+    // Type
-    Time time;
+    if (header.version > 1) {
-    Terrain terrain;
+        TypeV2 type;
-    Music music;
+    }
+    else {
+        Type type;
+    }
+    // Skybox
+    if (header.version > 1) {
+        if (header.gameVersion == "0.95") {
+            SkyboxV3 skybox;
+        }
+        else {
+            SkyboxV2 skybox;
+        }
+    }
+    else {
+        Skybox skybox;
+    }
+    // Scenery
+    if (header.version == 1) {
+        Scenery scenery;
+    }
+    else if (header.version > 1 && header.version < 4) {
+        SceneryV2 scenery;
+    }
+    else {
+        if (header.gameVersion == "0.95") {
+            SceneryV5 skybox;
+        }
+        else {
+            SceneryV4 skybox;
+        }
+    }
+    // Weather
+    if (header.version > 2) {
+        if (header.gameVersion == "0.95") {
+            WeatherV2 weather;
+        }
+        else {
+            Weather weather;
+        }
+    }
+    // Background music
+    if (header.version > 1) {
+        BGMV2 bgm;
+    }
+    else {
+        BGM bgm;
+    }
+    // Time Trial
+    if (type == Type::Trial) {
+        u32 timeTrialTicksBronze;
+        u32 timeTrialTicksSilver;
+        u32 timeTrialTicksGold;
+    }
 };
 
 struct Object {
     std::string::SizedString<u8> objName;
-    u32 x;
+    if (header.version > 1) {
-    u32 y;
+        u16 x;
+        u16 y;
+        bool hasMetafields;
+        if (hasMetafields) {
+            u16 numOfMetafields;
+            u8 metafields[numOfMetafields];
+        }
+    }
+    else {
+        u32 x;
+        u32 y;
+    }
 };
 
 struct Objects{
@@ -68,6 +366,6 @@ struct Objects{
     std::Array<Object, objCount> objArray;
 };
 
-Header header @ 0x0;
+Header header   @ $;
 Options options @ $;
 Objects objects @ $;

patterns/SHR.hexpat

@@ -0,0 +1,189 @@
+/*!
+    Apple IIgs Super Hi-Res (SHR) + PaintWorks Animation (ANI) — ImHex pattern
+
+    Supports:
+      • PIC $C1/$0000 — 32 KB uncompressed SHR screen image
+      • PIC $C1/$0002 — 3200-color (“Brooks”) per-scanline palettes
+      • ANI $C2/$0000 — PaintWorks animation:
+            0x0000..0x7FFF : base SHR $C1/$0000 image
+            0x8000..      : animation header + chunks
+
+    PaintWorks animation structure (per reversed docs):
+      - Base image: uncompressed SHR ($C1/$0000)
+      - +0x8000 u32: total animation data length after header (file_len - 0x8008)
+      - +0x8004 u16: global frame delay in VBLs
+      - +0x8006 u16: flag/? (commonly 0x00C0 or 0x00C1)
+      - +0x8008 ...: one or more animation chunks:
+            chunk:
+              u32 chunk_len           (includes this length field)
+              repeated { u16 offset; u16 value; } pairs
+              offset==0x0000 marks End-of-Frame (value is ignored)
+      - Offsets may target any byte in the 32 KB SHR space (pixels, SCBs, palettes).
+        This enables palette-cycling and SCB effects.
+
+    References:
+      - CiderPress2 PaintWorks Animation notes (file structure, fields, semantics).
+*/
+
+import std.core;
+import std.sys;
+import std.math;
+
+#pragma endian little
+#include <std/mem.pat>
+
+#pragma description Apple IIgs Super Hi-Res (SHR) + PaintWorks Animation (ANI)
+#pragma author hasseily
+
+
+// ------------------------------ Constants ------------------------------
+
+const u32 SHR_ROWS                 = 200;
+const u32 SHR_BYTES_PER_ROW        = 160;
+const u32 SHR_PIXEL_DATA_SIZE      = SHR_ROWS * SHR_BYTES_PER_ROW; // 32000 (0x7D00)
+
+const u32 PIC0000_FILE_SIZE        = 0x8000;  // 32768
+const u32 PIC0002_FILE_SIZE        = 0x9600;  // 38400 (32000 + 200*32)
+
+const u32 PIC0000_OFF_PIXELS       = 0x0000;
+const u32 PIC0000_OFF_SCB          = 0x7D00;
+const u32 PIC0000_OFF_RESERVED     = 0x7DC8;
+const u32 PIC0000_OFF_PALETTES     = 0x7E00;
+
+const u32 PALETTE_COUNT            = 16;
+const u32 PALETTE_COLORS           = 16;
+
+const u32 ANI_BASE_SHR_SIZE        = 0x8000;  // First 32 KB is a $C1/$0000 image
+const u32 ANI_HDR_OFF              = 0x8000;  // Animation header starts here
+const u32 ANI_MIN_TOTAL_SIZE       = 0x8008;  // base + header (no chunks)
+
+// ------------------------------ Types: SHR core ------------------------------
+
+struct Row160 { u8 data[SHR_BYTES_PER_ROW]; };
+
+// Scanline Control Byte
+bitfield ShrSCB {
+    palette    : 4;  // 0..15
+    reserved   : 1;
+    color_fill : 1;
+    interrupt  : 1;
+    mode_640   : 1;  // 0=320, 1=640
+};
+
+// helper: expand a 4-bit channel to 8-bit (0x0..0xF -> 0x00..0xFF)
+fn expand4(u8 v) { return (v << 4) | v; };
+
+bitfield Colors_gb {
+    blue : 4;   // Blue  (B3..B0)
+    green : 4;   // Green (G3..G0)
+};
+
+bitfield Colors_r0 {
+    red : 4;      // Red   (R3..R0)
+    unused : 4;   // Unused / reserved
+};
+    
+// RGB444 stored as 0RGB
+struct Rgb444_0RGB {
+    Colors_gb gb;
+    Colors_r0 r0;
+} [[color(std::format("{:02X}{:02X}{:02X}", expand4(r0.red), expand4(gb.green), expand4(gb.blue)))]];
+
+struct Palette16 { Rgb444_0RGB color[PALETTE_COLORS]; };
+
+// $C1/$0000 raw 32 KB screen dump
+struct SHR_PIC0000 {
+    Row160    pixels[SHR_ROWS]            @ PIC0000_OFF_PIXELS;
+    ShrSCB    scb[SHR_ROWS]               @ PIC0000_OFF_SCB;
+    u8        reserved[56]                @ PIC0000_OFF_RESERVED;
+    Palette16 palettes[PALETTE_COUNT]     @ PIC0000_OFF_PALETTES;
+};
+
+// “Brooks” 3200-color: pixels + 200 per-line palettes (no SCBs)
+struct BrooksLinePalette { Rgb444_0RGB color[PALETTE_COLORS]; };
+
+struct SHR_PIC0002 {
+    Row160             pixels[SHR_ROWS]                 @ 0x0000;
+    BrooksLinePalette  line_palettes[SHR_ROWS]          @ SHR_PIXEL_DATA_SIZE; // 0x7D00
+};
+
+// ------------------------------ Types: PaintWorks ANI ($C2/$0000) ------------------------------
+
+/* Each operation modifies 1 word at an absolute offset in the 32 KB SHR area.
+   End-of-frame marker: offset == 0x0000 (value is ignored). */
+struct AniOp {
+    u16 offset [[color("0000AA")]];   // 0x0000..0x7FFE valid; 0x0000 = End-of-Frame
+    u16 value [[color("00AAAA")]];    // word to store at [offset]
+    // For convenience in the sidebar:
+    bool is_eof = (offset == 0x0000);
+};
+
+// A contiguous animation chunk: length + packed AniOp pairs.
+// Most files have exactly one chunk that spans all frames.
+struct AniChunk {
+    u32  chunk_len;   // includes this field
+
+    // ops_count = (chunk_len - 4)/4, unless chunk_len == 4
+    // in which case: (__file_size - 0x8000 - 12)/4
+    u64 ops_count64 =
+        (chunk_len == 4)
+            ? ( (__file_size > (0x8000 + 12)) ? ((__file_size - 0x8000 - 12) / 4) : 0 )
+            : ( (chunk_len >= 4) ? (u64(chunk_len - 4) / 4) : 0 );
+
+    u32 ops_count = u32(ops_count64);
+
+    // ops start immediately after chunk_len (offset +4)
+    AniOp ops[ops_count];
+};
+
+// Header located at 0x8000 after the base 32 KB image
+struct AniHeader {
+    u32 anim_data_len [[color("660000")]];    // total bytes of animation data after header
+    u16 frame_delay_vbl [[color("CC0000")]];  // global per-frame delay in VBLs (NTSC/PAL differ)
+    u16 flag_unknown;     // usually 0x00C0 or 0x00C1
+};
+
+// Full PaintWorks animation container
+struct ANI_PaintWorks {
+    // Base frame: a normal uncompressed SHR image
+    SHR_PIC0000 base                                  @ 0x0000;
+
+    // Global animation header
+    AniHeader   hdr                                   @ ANI_HDR_OFF;
+
+    // One or more chunks, typically exactly one:
+    AniChunk    chunks[ std::math::min(
+                          u32(16), // cap to keep ImHex happy in pathological cases
+                          u32((__file_size - (ANI_HDR_OFF + sizeof(AniHeader))) > 3 ?
+                                1 + u32((__file_size - (ANI_HDR_OFF + sizeof(AniHeader))) / 0x10000000) :
+                                1)
+                      ) ]                              @ (ANI_HDR_OFF + sizeof(AniHeader));
+
+    // Helpful computed values for inspection:
+    u64 file_len              = __file_size;
+    u64 expected_anim_end     = ANI_HDR_OFF + sizeof(AniHeader) + u64(hdr.anim_data_len);
+};
+
+// ------------------------------ Dispatcher ------------------------------
+
+u64 __file_size = std::mem::size();
+
+if (__file_size == PIC0000_FILE_SIZE) {
+    // Plain SHR dump
+    SHR_PIC0000 pic0000 @ 0x0000;
+
+} else if (__file_size == PIC0002_FILE_SIZE) {
+    // Brooks 3200-color
+    SHR_PIC0002 pic0002 @ 0x0000;
+
+} else if (__file_size >= ANI_MIN_TOTAL_SIZE) {
+    // Heuristic: treat as PaintWorks ANI if there’s room for base+header.
+    // (Many PW ANI files use ProDOS type $C2/$0000.)
+    ANI_PaintWorks ani @ 0x0000;
+
+} else if (__file_size >= SHR_PIXEL_DATA_SIZE) {
+    // Fallback: show pixels only for odd dumps
+    Row160 pixels_only[SHR_ROWS] @ 0x0000;
+}
+
+ANI_PaintWorks ani_paintworks_at_0 @ 0;

patterns/adtfdat.hexpat

@@ -0,0 +1,176 @@
+#pragma description ADTFDAT File
+
+#pragma magic [ 49 46 48 44 ] @ 0x00
+#pragma endian little
+
+import std.io;
+import std.mem;
+import type.time;
+
+enum FileVersion : u32 {
+  with_history_end_offset = 0x00000301,
+  v500 = 0x00000500
+};
+
+bitfield ChunkFlags {
+  key : 1;
+  info : 1;
+  marker : 1;
+  type : 1;
+  trigger : 1;
+  reserved: 11;
+};
+
+struct Extension
+{
+    char identifier[384];
+    u16 stream_id;
+    u8 reserved1[2];
+    u32 user_id;
+    u32 type_id;
+    u32 version_id;
+    u64 data_pos;
+    u64 data_size;
+    u8 reserved[96];
+    u8 payload[data_size] @ data_pos;
+};
+
+struct ChunkHeader {
+    u64 time_stamp [[format("format_timestamp_with_offset")]];;
+    u32 ref_master_table_index;
+    u32 offset_to_last;
+    u32 size;
+    u16 stream_id;
+    ChunkFlags flags;
+    u64 stream_index;
+};
+
+struct SampleInfo {
+    u8 memory_layout_version;
+    u32 size;
+    u8 payload[size];
+};
+
+struct Sample {
+    s64 timestamp [[format("format_timestamp")]];;
+    s32 flags;
+    u64 buffer_size;
+    u8 payload[buffer_size];
+    if (flags & 0x100) {
+        SampleInfo sample_info;
+    }
+    if (flags & 0x200) {
+        u32 substream_id;
+    } else {
+        u32 substream_id = 0 [[export]];
+    }
+};
+
+struct Chunk {
+    auto start_address = $;
+
+    ChunkHeader header;
+
+    if (header.size < 32 || start_address + header.size > std::mem::size()) {
+        std::warning(std::format("Invalid header size {} in chunk {} at offset 0x{:X}, last valid chunk at 0x{:X}.", header.size, chunk_index, start_address, last_valid_chunk_offset));
+        break;
+    }
+
+    last_valid_chunk_offset = start_address;
+
+    u8 payload[header.size - 32];
+
+    if (!skip_valid_chunks) {
+        if (!header.flags.info && !header.flags.marker && !header.flags.type && !header.flags.trigger) {
+            try {
+                Sample sample @ addressof(payload);
+            } catch {
+                std::warning(std::format("Invalid sample payload at chunk {} at 0x{:X}", chunk_index, start_address));
+            }
+        }
+    }
+
+    chunk_index += 1;
+
+    // Padding with 0xEE to the next chunk header
+    std::mem::AlignTo<16>;
+
+    if (skip_valid_chunks) {
+        continue;
+    }
+};
+
+struct Header {
+    u32 file_id;
+    u32 version_id;
+    u32 flags;
+    u32 extension_count;
+    u64 extension_offset;
+    u64 data_offset;
+    u64 data_size;
+    u64 chunk_count;
+    u64 max_chunk_size;
+    u64 duration;
+    type::time64_t filetime;
+    u8 header_byte_order;
+    u64 time_offset [[format("format_timestamp")]];
+    u8 patch_number;
+    u64 first_chunk_offset;
+    u64 continuous_offset;
+    u64 ring_buffer_end_offset;
+    u8 reserved[30];
+    char description[1912];
+};
+
+struct IndexedFile {
+    Header header;
+    Extension extensions[header.extension_count] @ header.extension_offset;
+
+    if (header.version_id >= FileVersion::with_history_end_offset &&
+        header.continuous_offset != header.data_offset) {
+        try {
+            Chunk ring_front[while($ < header.continuous_offset)] @ header.first_chunk_offset;
+            Chunk ring_back[while($ < header.ring_buffer_end_offset)] @ header.data_offset;
+            Chunk continueous[header.chunk_count - chunk_index] @ header.continuous_offset;
+        } catch {
+            std::warning("Too many chunks. Performing check only.");
+            skip_valid_chunks = true;
+            chunk_index = 0;
+            Chunk ring_front[while($ < header.continuous_offset)] @ header.first_chunk_offset;
+            Chunk ring_back[while($ < header.ring_buffer_end_offset)] @ header.data_offset;
+            Chunk continueous[while(chunk_index < header.chunk_count)] @ header.continuous_offset;
+        }
+    } else {
+        try {
+            Chunk chunks[header.chunk_count] @ header.data_offset;
+        } catch {
+            std::warning("Too many chunks. Performing check only.");
+            skip_valid_chunks = true;
+            chunk_index = 0;
+            Chunk chunks[while(chunk_index < header.chunk_count)] @ header.data_offset;
+        }
+    }
+};
+
+fn format_timestamp(u64 data) {
+    double seconds = 0;
+    if (file.header.version_id < FileVersion::v500) {
+        // microseconds
+        seconds = data / double(1000000);
+    } else {
+        // nanoseconds
+        seconds = data / double(1000000000);
+    }
+
+    std::time::Time time64 = std::time::to_utc(seconds);
+    return std::time::format(time64);
+};
+
+fn format_timestamp_with_offset(u64 data) {
+    return format_timestamp(data + file.header.time_offset);
+};
+
+bool skip_valid_chunks = false;
+u64 last_valid_chunk_offset = 0;
+u64 chunk_index = 0;
+IndexedFile file @ 0x00;

patterns/adts.hexpat

@@ -0,0 +1,197 @@
+#pragma author zhoubo
+#pragma description AAC ADTSn (Audio Data Transport Stream) Audio
+#pragma MIME audio/x-hx-aac-adts
+#pragma pattern_limit 0xFFFFFF
+
+// History
+// 0.4  2024-02-12 zhoubo: Porting from 010 Editor Templates.
+// 0.3  2024-02-09 zhoubo: use BitfieldDisablePadding(Unpadded Bitfields) for odd header bytes(7,9 bytes) color, and remove FSeek.
+// 0.2  2024-02-05 zhoubo: fix some comment & color.
+// 0.1  2022-06-13 zhoubo: Init release. only ADTS, not support ADIF,LATM.
+
+// More information available at:
+//  1. https://wiki.multimedia.cx/index.php?title=ADTS
+//  2. https://en.wikipedia.org/wiki/Advanced_Audio_Coding
+//  3. https://en.wikipedia.org/wiki/AAC
+//  4. https://juejin.cn/post/7032170229732442148
+
+#pragma endian big
+
+#include <std/sys.pat>
+#include <std/core.pat>
+
+fn GetMPEGVersionComment(auto MPEG_Version)
+{
+    str comment = "";
+    match (MPEG_Version)
+    {
+    (0):          comment = "MPEG-4";
+    (1):          comment = "MPEG-2";
+    }
+    return comment;
+};
+
+fn GetProtectionAbsentComment(auto Protection_absence)
+{
+    str comment = "";
+    match (Protection_absence)
+    {
+    (0):          comment = "ADTS has 9 bytes with CRC";
+    (1):          comment = "ADTS has 7 bytes without CRC";
+    }
+    return comment;
+};
+
+fn GetProfileComment(auto Profile)
+{
+    str comment = "";
+    match (Profile)
+    {
+    (0x00):       comment = "AAC Main";
+    (0x01):       comment = "AAC LC (Low Complexity)";
+    (0x10):       comment = "AAC SSR (Scalable Sample Rate)";
+    (0x11):       comment = "AAC LTP (Long Term Prediction)";
+    }
+    return comment;
+};
+
+fn GetSamplingFrequencyIndexComment(auto Sampling_frequency_index)
+{
+    str comment = "";
+    match (Sampling_frequency_index)
+    {
+    (0x0):        comment = "96000Hz";
+    (0x1):        comment = "88200Hz";
+    (0x2):        comment = "64000Hz";
+    (0x3):        comment = "48000Hz";
+    (0x4):        comment = "44100Hz";
+    (0x5):        comment = "32000Hz";
+    (0x6):        comment = "24000Hz";
+    (0x7):        comment = "22050Hz";
+    (0x8):        comment = "16000Hz";
+    (0x9):        comment = "12000Hz";
+    (0xa):        comment = "11025Hz";
+    (0xb):        comment = "8000Hz";
+    (0xc):        comment = "7350Hz";
+    (0xd):        comment = "Reserved";
+    (0xe):        comment = "Reserved";
+    (0xf):        comment = "FORBIDDEN (malformed)";
+    }
+    return comment;
+};
+
+fn GetChannelConfigurationComment(auto Channel_configuration)
+{
+    str comment = "";
+    match (Channel_configuration)
+    {
+    (0):          comment = "Defined in AOT Specifc Config";
+    (1):          comment = "1 channel: front-center";
+    (2):          comment = "2 channels: front-left, front-right";
+    (3):          comment = "3 channels: front-center, front-left, front-right";
+    (4):          comment = "4 channels: front-center, front-left, front-right, back-center";
+    (5):          comment = "5 channels: front-center, front-left, front-right, back-left, back-right";
+    (6):          comment = "6 channels: front-center, front-left, front-right, back-left, back-right, LFE-channel";
+    (7):          comment = "8 channels: front-center, front-left, front-right, side-left, side-right, back-left, back-right, LFE-channel";
+    }
+    return comment;
+};
+
+fn GetBufferFullnessComment(auto ADTS_buffer_fullness)
+{
+    str comment = "";
+    match (ADTS_buffer_fullness)
+    {
+    (0x7FF):      comment = "VBR (most software ignore this field)";
+    (_):          comment = "rate..?? (most software ignore this field)";
+    }
+    return comment;
+};
+
+fn GetRawDataBlockComment(auto Number_of_AAC_frames_minus_1)
+{
+    str comment = "";
+    match (Number_of_AAC_frames_minus_1)
+    {
+    (0x0):        comment = "has 1 AAC data block";
+    (_):          comment = "data block number + 1";
+    }
+    return comment;
+};
+
+
+//-----------------------------------
+// Define structures used in AAC files
+//
+// [1.adts_fixed_header information]
+// Syncword:                     12bits, sync header, always 0xFFF。
+// MPEG_Version:                 1bit,   0 means MPGE-4, 1 means MPGE-2
+// Layer:                        2bits,  alwayas ”00”
+// Protection_absence:           1bit,   0 means ADTS Header 9 bytes; 1 means ADTS Header 7 bytes
+// Profile:                      2bit,   AAC level : Main,LC,SSR,LTP
+// Sampling_frequency_index:     4bits,  Sampling Frequencies
+// Private_bit:                  1bit
+// Channel_configuration:        3bits,  channel number...
+// Originality:                  1bit
+// Home:                         1bit
+//
+// [2.adts_variable_header information]
+// Copyright_id_bit:             1bit
+// Copyright_id_start:           1bit
+// AAC_frame_length:             13bits, AAC frame length : ADTS Header(7 or 9 bytes) + sizeof(AAC Frame)
+// ADTS_buffer_fullness:         11bits, 0x7FF means VBR
+// Number_of_AAC_frames_minus_1: 2bits,  ADTS Frame numbers : Number_of_AAC_frames_minus_1 + 1
+//
+// [3.CRC information]
+// CRC16:                        16bits, when Protection_absence=0
+
+bitfield ADTS_HEADER
+{
+    // ADTS_FIXED_HEADER
+    Syncword : 12                     [[color("00FF00"), comment("always 0xFFF")]];
+    MPEG_Version : 1                  [[color("00FF00"), comment(GetMPEGVersionComment(this))]];
+    Layer : 2                         [[color("00FF00"), comment("always 0")]];
+    Protection_absence : 1            [[color("00FF00"), comment(GetProtectionAbsentComment(this))]];
+
+    Profile : 2                       [[color("0000FF"), comment(GetProfileComment(this))]];
+    Sampling_frequency_index : 4      [[color("0000FF"), comment(GetSamplingFrequencyIndexComment(this))]];
+    Private_bit : 1                   [[color("0000FF")]];
+    Channel_configuration : 3         [[color("0000FF"), comment(GetChannelConfigurationComment(this))]];
+    Originality : 1                   [[color("0000FF")]];
+    Home : 1                          [[color("0000FF")]];
+
+    // ADTS_VARIABLE_HEADER
+    Copyright_id_bit : 1              [[color("0000FF")]];
+    Copyright_id_start : 1            [[color("0000FF")]];
+    AAC_frame_length : 13             [[color("0000FF")]];
+    ADTS_buffer_fullness : 11         [[color("0000FF"), comment(GetBufferFullnessComment(this))]];
+    Number_of_AAC_frames_minus_1 : 2  [[color("0000FF"), comment(GetRawDataBlockComment(this))]];
+
+    // ADTS_CRC_HEADER
+    if (0 == Protection_absence) // Header with CRC
+    {
+        u16 CRC16                     [[color("FFFF00")]];
+    }
+    else // Header without CRC
+    {
+    }
+};
+
+
+struct ADTS_FRAME
+{
+    ADTS_HEADER Header;
+
+    if (0 == Header.Protection_absence) // Header with CRC 2 bytes
+    {
+        u8 Data[Header.AAC_frame_length - 9]   [[color("000000")]];
+    }
+    else // Header without CRC
+    {
+        u8 Data[Header.AAC_frame_length - 7]   [[color("000000")]];
+    }
+};
+
+//---------------------------------------------
+
+ADTS_FRAME adtsFrame[while(!std::mem::eof())] @ 0x00;

patterns/afe2.hexpat

@@ -1,7 +1,14 @@
+#pragma author WerWolv
+#pragma description Nintendo Switch Atmosphère CFW Fatal Error log
+
+#pragma magic [ 41 46 45 30 ] @ 0x00
+#pragma magic [ 41 46 45 31 ] @ 0x00
+#pragma magic [ 41 46 45 32 ] @ 0x00
+
 #pragma endian little
 
-#include <std/io.pat>
+import std.io;
-#include <std/sys.pat>
+import std.sys;
 
 #define ATMOSPHERE_REBOOT_TO_FATAL_MAGIC   	"AFE2"
 #define ATMOSPHERE_REBOOT_TO_FATAL_MAGIC_1 	"AFE1"
@@ -49,8 +56,8 @@ std::assert(ctx.magic == ATMOSPHERE_REBOOT_TO_FATAL_MAGIC   ||
        ctx.magic == ATMOSPHERE_REBOOT_TO_FATAL_MAGIC_1 ||
        ctx.magic == ATMOSPHERE_REBOOT_TO_FATAL_MAGIC_0,
        "File is not a valid Atmosphere fatal error binary!");
-	   
+
-std::assert_warn(ctx.magic == ATMOSPHERE_REBOOT_TO_FATAL_MAGIC, 
+std::assert_warn(ctx.magic == ATMOSPHERE_REBOOT_TO_FATAL_MAGIC,
            "Atmosphere fatal error binary is for an older version!");
 
 

patterns/ani.hexpat

@@ -0,0 +1,71 @@
+#pragma description Windows animated cursor
+#pragma MIME application/x-navi-animation
+#pragma endian little
+
+import std.io;
+import std.mem;
+
+bitfield HeaderFlags {
+    icon : 1;
+    sequence : 1;
+    padding: 30;
+};
+
+struct anih {
+    u32 struct_size;
+    u32 stored_frames;
+    u32 animation_steps;
+    u32 w;
+    u32 h;
+    u32 bits;
+    u32 planes;
+    u32 default_jiffies;
+    HeaderFlags flags;
+};
+
+struct rate {
+    u32 jiffies[parent.size / 4];
+};
+
+struct seq {
+    u32 index[parent.size / 4];
+};
+
+struct RiffChunk {
+    char signature[4];
+    u32 size;
+    if (signature == "RIFF" || signature == "LIST") {
+        char type[4];
+
+        // Compatible with error size defined in ani files
+        u32 remain = sizeof($) - addressof(type);
+        u32 marked = size > remain ? remain : size;
+
+        RiffChunk chunks[while($ - addressof(type) < marked)];
+    } else if (signature[0] == 'I' && parent.type == "INFO") {
+        char info[size];
+    } else if (signature == "anih") {
+        anih anih [[inline]];
+    } else if (signature == "rate") {
+        rate rate [[inline]];
+    } else if (signature == "seq ") {
+        seq seq [[inline]];
+    } else {
+        std::mem::Bytes<size> data;
+    }
+    padding[size % 2];
+} [[format_read("read_chunk")]];
+
+fn read_chunk(RiffChunk chunk) {
+    if (chunk.signature == "RIFF" || chunk.signature == "LIST") {
+        return std::format("{}<{}> ({})", chunk.signature, chunk.type, chunk.size);
+    } else {
+        str ret = std::format("{} ({})", chunk.signature, chunk.size);
+        try {
+            ret += std::format(" \"{}\"", chunk.info);
+        } catch {}
+        return ret;
+    }
+};
+
+RiffChunk riff @ 0;

patterns/apple_single_double.hexpat

@@ -0,0 +1,50 @@
+#pragma author Lexi Mayfield
+#pragma description AppleSingle/AppleDouble file format
+#pragma endian big
+#pragma magic [00 05 16 0?] @ 0x00
+
+import type.magic;
+
+enum EntryID : u32 {
+    DataFork = 1,
+    ResourceFork = 2,
+    RealName = 3,
+    Comment = 4,
+    IconBW = 5,
+    IconColor = 6,
+    FileDatesInfo = 8,
+    FinderInfo = 9,
+    MacFileInfo = 10,
+    ProDOSFileInfo = 11,
+    MSDOSFileInfo = 12,
+    ShortName = 13,
+    AFPFileInfo = 14,
+    DirectoryID = 15,
+};
+
+struct Entry {
+    EntryID entryID;
+    u32 offset;
+    u32 length;
+    u8 data[length] @ offset [[sealed]];
+};
+
+enum FileType : u32 {
+    AppleSingle = 0x00051600,
+    AppleDouble = 0x00051607,
+};
+
+enum Version : u32 {
+    V1 = 0x00010000,
+    V2 = 0x00020000,
+};
+
+struct AppleSingleDouble {
+    FileType fileType;
+    Version version;
+    char homeFileSystem[16];
+    u16 numEntries;
+    Entry entryDescs[numEntries];
+};
+
+AppleSingleDouble appleSingleDouble @ 0x00;

patterns/ar.hexpat

@@ -1,8 +1,11 @@
+#pragma author WerWolv
+#pragma description GNU Static library archive
+
 #pragma MIME application/x-archive
 
-#include <std/string.pat>
+import std.string;
-#include <std/mem.pat>
+import std.mem;
-#include <std/sys.pat>
+import std.sys;
 
 struct ARFile {
 	char file_name[16];
@@ -12,7 +15,7 @@ struct ARFile {
 	char file_mode[8];
 	char file_size[10];
 	u16 end_marker;
-	
+
 	if (end_marker == 0x0A60) {
 		u8 data[std::string::parse_int(this.file_size, 10)];
 		padding[sizeof(data) & 1];
@@ -20,6 +23,9 @@ struct ARFile {
 };
 
 char signature[8] @ 0x00;
+if (signature == "!<arch>\r") {
+    std::error("Archive file got corrupted due to CRLF line ending conversion!");
+}
 std::assert(signature == "!<arch>\n", "File is not a valid archive!");
 
 ARFile files[while($ < std::mem::size())] @ $;

patterns/arc.hexpat

@@ -0,0 +1,26 @@
+#pragma author DexrnZacAttack
+#pragma description Minecraft LCE ARC File
+#pragma endian big
+
+import std.string;
+#ifdef __IMHEX__
+    import hex.core;
+#endif
+
+struct Table {
+    u16 nameSize;
+    char fileName[nameSize];
+    u32 offset;
+    u32 size;
+    u8 file[size] @ offset;
+    #ifdef __IMHEX__
+        hex::core::add_virtual_file(fileName, file);
+    #endif
+} [[name(std::string::to_string(fileName))]];
+
+struct ARC {
+    u32 count;
+    Table table[count];
+};
+
+ARC arc @ 0x00;

patterns/aria2.hexpat

@@ -0,0 +1,36 @@
+#pragma author itsmeow
+#pragma description aria2 Control File
+
+#pragma endian big
+
+/*
+Format sourced from:
+https://aria2.github.io/manual/en/html/technical-notes.html#control-file-aria2-format
+
+Version 0 files are not supported by default
+However parsing one is as simple as changing to #pragma endian ittle
+and resolving any errors resulting from that by adding be prefixes to struct fields.
+*/
+
+struct AriaInFlight {
+    u32 index;
+    u32 length;
+    u32 bitfield_piece_length;
+    u8 bitfield_p[bitfield_piece_length];
+};
+
+struct AriaHeader {
+    u16 version;
+    u32 extension;
+    u32 infohash_length;
+    u8 infohash[infohash_length];
+    u32 piece_length;
+    u64 total_length;
+    u64 upload_length;
+    u32 bitfield_length;
+    u8 bitfield_d[bitfield_length];
+    u32 inflight_count;
+    AriaInFlight inflights[inflight_count];
+};
+
+AriaHeader aria_header @ 0x00;

patterns/arm_cm_vtor.hexpat

@@ -1,7 +1,10 @@
+#pragma author WerWolv
+#pragma description ARM Cortex M Vector Table Layout
+
 #pragma endian little
 
-#include <std/io.pat>
+import std.io;
-#include <std/mem.pat>
+import std.mem;
 
 #define VTOR	0x00000000
 #define EXTERNAL_INTERRUPT_COUNT	64
@@ -37,21 +40,21 @@ VectorTable vector_table @ VTOR;
 
 fn main() {
 	u32 table_size = sizeof(vector_table);
-	
+
 	u32 default_handler_address = 0x00;
-	
+
 	for (u32 i = 4, i < table_size, i = i + 4) {
 		u32 occurrences = 0;
 		for (u32 j = 4, j < table_size, j = j + 4) {
 			if (std::mem::read_unsigned(i, 4) == std::mem::read_unsigned(j, 4)) {
 				occurrences = occurrences + 1;
-				
+
 				if (occurrences > 1)
 					default_handler_address = std::mem::read_unsigned(i, 4);
 			}
 		}
 	}
-	
+
 	if (default_handler_address != 0x00)
 		std::print("Default Handler implementation at 0x{:08X}", default_handler_address);
 };

patterns/bcss.hexpat

@@ -0,0 +1,168 @@
+#pragma author ttimasdf
+#pragma description BeyondCompare Snapshot (BCSS) file
+
+#pragma magic [42 43 53 53] @ 0x00
+
+#pragma array_limit 4294967295
+#pragma pattern_limit 4294967295
+
+
+import std.io;
+import std.mem;
+import std.array;
+import std.string;
+import type.magic;
+
+#ifdef __IMHEX__
+import hex.dec;
+import hex.core;
+#endif
+
+
+const u8 max_path_size = 1000;
+str current_path[max_path_size];
+u8 current_path_level = 0;
+
+enum EntryType : u8 {
+    DIRECTORY   = 0x01,
+    FILE        = 0x02,
+    SYMLINK     = 0x03,
+    // NULL        = 0x00,
+    DIR_END     = 0xFF,
+};
+
+struct BCSSEntry {
+    EntryType type;
+    match (type) {
+        (EntryType::DIRECTORY) : {
+            // FileName name;
+            std::string::SizedString<u8> name;
+            if (name.size != 0) {
+                u8 unknown[12];
+                on_dir_enter(name.data);  // std::string::to_string(name)
+            } else {
+                // some buggy edge cases
+                u8 unknown[6];
+                std::warning(std::format("invalid empty entry current_lvl={} current_pos=0x{:02x}", current_path_level, $));
+            }
+        }
+        (EntryType::FILE) : {
+            std::string::SizedString<u8> name;
+            if (name.size != 0) {
+                u8 unknown[20];
+                #ifdef __IMHEX__
+                    hex::core::add_virtual_file(get_vfs_path(name), this);  // std::string::to_string(name)
+                #endif
+            } else {
+                // some buggy edge cases
+                u8 unknown[6];
+                std::warning(std::format("invalid empty entry current_lvl={} current_pos=0x{:02x}", current_path_level, $));
+            }
+            //try {
+            //    u8 unknown[20];
+            //} catch {
+            //    u8 unknown[0];
+            //}
+        }
+        (EntryType::SYMLINK) : {
+            std::string::SizedString<u8> name;
+            u8 unknown[23];
+            std::string::SizedString<u8> target;
+            #ifdef __IMHEX__
+                hex::core::add_virtual_file(get_vfs_path(name + " [s]"), this);  // std::string::to_string(name)
+            #endif
+        }
+        (EntryType::DIR_END) : {
+            on_dir_exit();
+        }
+        // (EntryType::NULL) : {
+        //     // some buggy edge cases
+        //     u8 unknown[7];
+        //     std::warning(std::format("invalid empty entry current_lvl={} current_pos=0x{:02x}", current_path_level, $));
+        // }
+        (_): {
+            std::error(std::format("unknown EntryType idx={} current_pos=0x{:02x}", std::core::array_index(), $));
+        }
+    }
+}[[format_read("fmt_BCSSEntry")]];
+
+fn on_dir_enter(str folder_name) {
+    // std::print("on_dir_enter folder={} current_lvl={}", folder_name, current_path_level);
+    if (std::string::length(folder_name) > 0) {
+        current_path[current_path_level] = folder_name;
+        current_path_level += 1;
+    } else {
+        std::warning(std::format("invalid folder name {} current_lvl={} current_pos=0x{:02x}", folder_name, current_path_level, $));
+    }
+};
+
+fn on_dir_exit() {
+    if (current_path_level > 0) {
+        current_path_level -= 1;
+    } else if (!std::mem::eof()) {
+        std::warning(std::format("on_dir_exit current_lvl already == 0 current_pos=0x{:02x}", $));
+    }
+    // std::print("on_dir_exit current_lvl={}", current_path_level);
+};
+
+fn get_vfs_path(str file_name) {
+    str vfs_path = "";
+    if (current_path_level > 0) {
+        vfs_path = current_path[0];
+        for(u8 i = 1, i < current_path_level, i += 1) {
+            //hash_hex = hash_hex + std::format("{:02X}",bytes[i]);
+            vfs_path = vfs_path + "/" + current_path[i];
+        }
+        return vfs_path + "/" + file_name;
+    } else {
+        return file_name;
+    }
+};
+
+
+fn fmt_BCSSEntry(BCSSEntry e) {
+    try {
+        match (e.type) {
+            (EntryType::DIRECTORY | EntryType::FILE) : {
+                return std::format("{}: {}", (e.type == EntryType::DIRECTORY ? "Dir" : "File"), e.name.data);
+            }
+            (EntryType::SYMLINK) : {
+                return std::format("Symlink: {} -> {}", e.name.data, e.target.data);
+            }
+            (EntryType::DIR_END) : {
+                return "Directory End";
+            }
+        }
+    } catch {
+        return "[FmtErr]";
+    }
+};
+
+struct BCSSFile {
+    if (std::mem::read_unsigned(0, 4) == 0x53534342) {
+        type::Magic<"BCSS"> magic;
+        u8 unknown[14];
+        std::string::SizedString<u16> root_path;
+
+        u8 zlib_content[std::mem::size()-$];
+
+        // manually add zlib header which is essential for hex::dec::zlib_decompress
+        const str zlib_header = "\x78\x9c";
+        std::mem::Section zlib_compressed = std::mem::create_section("zlib_compressed");
+        std::mem::copy_value_to_section(zlib_header, zlib_compressed, 0);
+        std::mem::copy_value_to_section(zlib_content, zlib_compressed, 2);
+        u8 zlib[std::mem::get_section_size(zlib_compressed)] @ 0x00 in zlib_compressed;
+
+        #ifdef __IMHEX__
+            std::mem::Section zlib_decompressed = std::mem::create_section("zlib_decompressed");
+            hex::dec::zlib_decompress(zlib, zlib_decompressed, 15);
+            u8 decompressed_content[std::mem::get_section_size(zlib_decompressed)] @ 0x00 in zlib_decompressed;
+            hex::core::add_virtual_file("bcss_content", decompressed_content);
+            std::warning("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n! BCSS file content is compressed !\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\nopen `bcss_content` file from the Virtual Filesystem tab and run this pattern on it.");
+        #endif
+    } else {
+        BCSSEntry entries[while(!std::mem::eof())];
+    }
+};
+
+BCSSFile bcss_file @ 0x00;

patterns/bencode.hexpat

@@ -1,73 +1,85 @@
-#pragma MIME application/x-bittorrent
+#pragma author WerWolv
-
+#pragma description Torrent data (Bencode)
-#include <std/ctype.pat>
+
-#include <std/mem.pat>
+#pragma MIME application/x-bittorrent
-#include <std/string.pat>
+
-
+import std.ctype;
-namespace bencode {
+import std.mem;
-	
+import std.string;
-	struct ASCIIDecimal {
+
-		char value[while(std::ctype::isdigit(std::mem::read_unsigned($, 1)))];
+namespace bencode {
-	} [[sealed, format("bencode::format_ascii_decimal"), transform("bencode::format_ascii_decimal")]];
+
-	
+	struct ASCIIDecimal {
-	fn format_ascii_decimal(ASCIIDecimal adsasd) {
+		char value[while(std::ctype::isdigit(std::mem::read_unsigned($, 1)))];
-		return std::string::parse_int(adsasd.value, 10);
+	} [[sealed, format("bencode::format_ascii_decimal"), transform("bencode::format_ascii_decimal")]];
-	};
+
-	
+	fn format_ascii_decimal(ASCIIDecimal adsasd) {
-	enum Type : u8 {
+		return std::string::parse_int(adsasd.value, 10);
-		Integer = 'i',
+	};
-		Dictionary = 'd',
+
-		List = 'l',
+	enum Type : u8 {
-		
+		Integer = 'i',
-		String0 = '0',
+		Dictionary = 'd',
-		String1 = '1',
+		List = 'l',
-		String2 = '2',
+
-		String3 = '3',
+		String0 = '0',
-		String4 = '4',
+		String1 = '1',
-		String5 = '5',
+		String2 = '2',
-		String6 = '6',
+		String3 = '3',
-		String7 = '7',
+		String4 = '4',
-		String8 = '8',
+		String5 = '5',
-		String9 = '9'
+		String6 = '6',
-	};
+		String7 = '7',
-	
+		String8 = '8',
-	struct String {
+		String9 = '9'
-		ASCIIDecimal length;
+	};
-		char separator [[hidden]];
+
-		char value[length];
+	struct String {
-	} [[sealed, format("bencode::format_string"), transform("bencode::format_string")]];
+		ASCIIDecimal length;
-	
+		char separator [[hidden]];
-	fn format_string(String string) {
+		char value[length];
-		return string.value; 
+	} [[sealed, format("bencode::format_string")]];
-	};
+
-	
+	fn format_string(String string) {
-	using Bencode;
+		for (u64 i = 0, i < string.length, i = i + 1) {
-	using Value;
+			if (!std::ctype::isprint(string.value[i])) {
-	
+				return "Contains non-printable characters";
-	struct DictionaryEntry {
+			}
-		String key;
+		}
-		Value value;
+		return std::format("\"{}\"", string.value);
-	};
+	};
-	
+
-	struct Value {
+	using Bencode;
-		Type type;
+	using Value;
-		
+
-		if (type == Type::Dictionary) {
+	struct DictionaryEntry {
-			DictionaryEntry entry[while(std::mem::read_unsigned($, 1) != 'e')];			
+		String key;
-		} else if (type == Type::Integer) {
+		Value value;
-			ASCIIDecimal value;
+	};
-			char end;
+
-		} else {
+	struct Value {
-			$ -= 1;
+		Type type;
-			String value;
+
-		}
+		if (type == Type::Dictionary) {
-	};
+			DictionaryEntry entry[while(std::mem::read_unsigned($, 1) != 'e')];
-	
+			char end;
-	struct Bencode {
+		} else if (type == Type::List) {
-		Value value[while(!std::mem::eof())] [[inline]];		
+			  Value entry[while(std::mem::read_unsigned($, 1) != 'e')];
-		char end;
+			  char end;
-	};
+		} else if (type == Type::Integer) {
-	
+			ASCIIDecimal value;
-}
+			char end;
-
+		} else {
-bencode::Bencode bencode @ 0x00;
+			$ -= 1;
+			String value;
+		}
+	};
+
+	struct Bencode {
+		Value value[while(!std::mem::eof())] [[inline]];
+		char end;
+	};
+
+}
+
+bencode::Bencode bencode @ 0x00;

patterns/bgcode.hexpat

@@ -0,0 +1,101 @@
+#pragma author Shadlock0133 (aka Aurora) / WerWolv
+#pragma description Prusa Binary G-Code
+#pragma magic [ 47 43 44 45 ] @ 0x00
+
+import type.magic;
+import std.mem;
+
+enum ChecksumType : u16 {
+    None = 0,
+    CRC32 = 1
+};
+
+enum BlockType : u16 {
+    FileMetadata = 0,
+    GCode = 1,
+    SlicerMetadata = 2,
+    PrinterMetadata = 3,
+    PrintMetadata = 4,
+    Thumbnail = 5
+};
+
+enum CompressionType : u16 {
+    NoCompression = 0,
+    Deflate = 1,
+    HeatshrinkWindowSize11 = 2,
+    HeatshrinkWindowSize12 = 3
+};
+
+struct BlockHeader {
+    BlockType type;
+    CompressionType compressionType;
+    u32 uncompressedSize;
+    
+    if (compressionType != CompressionType::NoCompression) {
+        u32 compressedSize;
+    }
+    
+    u32 dataSize = compressionType == CompressionType::NoCompression ? uncompressedSize : compressedSize;
+};
+
+enum Encoding : u16 {
+    INI = 0
+};
+
+struct Metadata {
+    Encoding encoding;
+    char data[parent.header.dataSize];
+};
+
+enum ImageFormat : u16 {
+    PNG = 0,
+    JPG = 1,
+    QOI = 2
+};
+
+struct Thumbnail {
+    ImageFormat format;
+    u16 width, height;
+    std::mem::Bytes<parent.header.dataSize> imageData;
+} [[hex::visualize("image", imageData)]];
+
+enum GCodeEncoding : u16 {
+    NoEncoding = 0,
+    MeatPack = 1,
+    MeatPackWithComments = 2
+};
+
+struct GCode {
+    GCodeEncoding encoding;
+    
+    std::mem::Bytes<parent.header.dataSize> gcode;
+};
+
+struct Block {
+    BlockHeader header;
+    
+    match (header.type) {
+        (BlockType::FileMetadata):    Metadata fileMetadata;
+        (BlockType::PrinterMetadata): Metadata printerMetadata;
+        (BlockType::Thumbnail):       Thumbnail thumbnail;
+        (BlockType::PrintMetadata):   Metadata printMetadata;
+        (BlockType::SlicerMetadata):  Metadata slicerMetadata;
+        (BlockType::GCode):           GCode gcode;
+        (_):                          std::error("Invalid Block type!");
+    }
+    
+    if (parent.checksumType != ChecksumType::None)
+        u32 checksum;
+};
+
+struct BGCode {
+    type::Magic<"GCDE"> magic;
+    u32 version;
+    std::assert(version == 1, "Only Version 1 is supported");
+    
+    ChecksumType checksumType;
+    
+    Block blocks[while(!std::mem::eof())];
+};
+
+BGCode bgcode @ 0x00;

patterns/binka.hexpat

@@ -0,0 +1,24 @@
+#pragma author DexrnZacAttack
+#pragma description RAD Game Tools BINKA (Bink Audio)
+#pragma magic [31 46 43 42] @ 0x00
+
+import std.string;
+import std.math;
+import type.magic;
+
+fn getDuration(u32 duration_ts, u32 sample_rate) {
+    return float(duration_ts) / float(sample_rate);
+};
+
+struct Binka {
+    type::Magic<"1FCB"> magic;
+    u8; // can't get this to change anything when using ffprobe
+    u8 channel_count [[name(std::format("Channel Count: {}", this))]];
+    u16 sample_rate [[name(std::format("Sample Rate: {}", this))]];
+    u32 duration_ts [[name(std::format("Duration: {}s", std::math::floor(getDuration(this, sample_rate))))]];
+    u32;
+    u32 size [[name(std::format("File Size: {} bytes", this))]];
+    u8 data[size - 20];
+};
+
+Binka binka @ 0x00;

patterns/blend.hexpat

@@ -0,0 +1,196 @@
+#pragma description Blender file
+#pragma magic [42 4C 45 4E 44 45 52] @ 0x00
+
+/*
+ * References:
+ * https://projects.blender.org/blender/blender
+ * https://github.com/facebook/zstd/blob/master/contrib/seekable_format/zstd_seekable_compression_format.md
+ *
+ * Refer to the following files/structs:
+ * source/blender/blenloader/intern/writefile.cc
+ * source/blender/blenkernel/BKE_main.hh BlendThumbnail
+ * source/blender/makesdna/DNA_sdna_types.h BHead
+ */
+
+// Increased the pattern limit to be able to evaluate all pixels of the embedded thumbnail.
+#pragma pattern_limit 1000000
+
+#ifdef __IMHEX__
+    import hex.dec;
+#endif
+
+import std.core;
+import std.io;
+import std.mem;
+import std.string;
+import std.sys;
+import type.color;
+import type.magic;
+
+// Useful for extracting the thumbnail if the rest of the blend file is corrupted or truncated.
+bool quitAfterThumbnailIsParsed in;
+// Allow the pattern evaluator to skip the thumbnail e.g. if evaluation takes too long.
+bool skipThumbnail in;
+
+struct BHead<Ptr> {
+    char code[4];
+    s32 len;
+    Ptr old;
+    s32 SDNAnr;
+    s32 nr;
+
+    // ENDB marks the last data block in the file.
+    if (code == "ENDB") {
+        break;
+    }
+};
+
+struct ThumbnailLine<auto width> {
+    type::RGBA8 pixels[width];
+};
+
+fn copyThumbnail(u32 height, ref auto lines, std::mem::Section target) {
+    for (s64 l = (height - 1), l >= 0, l = l - 1) {
+        u64 currentSectionSize = std::mem::get_section_size(target);
+        // Append the current line to section.
+        std::mem::copy_value_to_section(lines[l], target, currentSectionSize);
+    }
+};
+
+struct Thumbnail {
+    u32 width;
+    u32 height;
+    u128 size = width * height;
+    ThumbnailLine<width> lines[height];
+
+    // Generate the thumbnail section.
+    std::mem::Section thumbnailFlipped = std::mem::create_section("thumbnail");
+    copyThumbnail(height, lines, thumbnailFlipped);
+    type::RGBA8 image[size] @ 0x00 in thumbnailFlipped;
+}
+#ifdef __IMHEX__
+[[hex::visualize("bitmap", image, width, height)]]
+#endif
+;
+
+struct DataBlock<Ptr> {
+    BHead<Ptr> bHead;
+
+    if (bHead.SDNAnr == 0 && bHead.code == "TEST") {
+        if (skipThumbnail) {
+            u8 thumbnail[bHead.len]; // Interpret as raw binary data.
+        } else {
+            Thumbnail thumbnail;
+            auto thumbnailSize = sizeof(thumbnail);
+            std::assert(thumbnailSize == bHead.len,
+                std::format("The thumbnail (size={:#x}) does not fit exactly into its DataBlock (len={:#x})!",
+                            thumbnailSize, bHead.len));
+        }
+
+        if (quitAfterThumbnailIsParsed) {
+            break;
+        }
+    } else {
+        u8 data[bHead.len]; // Unknown. Interpret as raw binary data.
+    }
+};
+
+enum PointerSize : char {
+    POINTER_4BYTE = '_',
+    POINTER_8BYTE = '-'
+};
+
+enum Endianness : char {
+    BIG_ENDIAN = 'V',
+    LITTLE_ENDIAN = 'v'
+};
+
+struct Blend<auto inputSize> {
+    type::Magic<"BLENDER"> magic;
+    PointerSize pointerSize;
+    Endianness endianness;
+    char version[3];
+
+    match (endianness) {
+        (Endianness::LITTLE_ENDIAN): std::core::set_endian(std::mem::Endian::Little);
+        (Endianness::BIG_ENDIAN): std::core::set_endian(std::mem::Endian::Big);
+        (_): std::error("Invalid value for endianness!");
+    }
+
+    match (pointerSize) {
+        (PointerSize::POINTER_4BYTE): DataBlock<u32> dataBlock[while($ < inputSize)];
+        (PointerSize::POINTER_8BYTE): DataBlock<u64> dataBlock[while($ < inputSize)];
+        (_): std::error("Invalid pointer size!");
+    }
+};
+
+struct BlendWrapper {
+    u128 currentPos = $;
+    char magic[4] @ currentPos [[hidden]];
+
+    if (magic != "\x28\xB5\x2F\xFD") { // ZSTD magic
+        // Assume the blend file is uncompressed.
+        Blend<sizeof($)> blend @ currentPos;
+        return;
+    }
+} [[inline]];
+
+BlendWrapper blendWrapper @ 0x00;
+
+// Assume the blend file is ZSTD compressed.
+
+struct SeekTableFooter {
+    u32 numFrames;
+    char flag;
+    type::Magic<"\xB1\xEA\x92\x8F"> footerMagic;
+};
+
+u128 seekTableFooterSize = 9;
+SeekTableFooter seekTableFooter @ (sizeof($) - seekTableFooterSize);
+
+struct SeekTableEntry {
+    u32 compressedSize;
+    u32 uncompressedSize;
+};
+
+u128 seekTableEntrySize = 8;
+SeekTableEntry seekTableEntries[seekTableFooter.numFrames]
+    @ (addressof(seekTableFooter) - seekTableFooter.numFrames * seekTableEntrySize);
+
+struct SeekTableHeader {
+    type::Magic<"\x5E\x2A\x4D\x18"> magic;
+    u32 frameSize;
+};
+
+u128 seekTableHeaderSize = 8;
+std::assert(seekTableFooter.numFrames > 0, "The seek table must contain entries!");
+SeekTableHeader seekTableHeader @ (addressof(seekTableEntries[0]) - seekTableHeaderSize);
+
+u32 frameIndex = 0;
+
+struct ZSTDFrame {
+    u8 data[seekTableEntries[frameIndex].compressedSize];
+    frameIndex = frameIndex + 1;
+};
+
+ZSTDFrame zstdFrames[seekTableFooter.numFrames] @ 0x00;
+
+#ifdef __IMHEX__
+    std::mem::Section decompressedSection = std::mem::create_section("decompressedBlend");
+    u128 previousSectionSize = 0;
+
+    for (u32 i = 0, i < seekTableFooter.numFrames, i = i + 1) {
+        std::assert(hex::dec::zstd_decompress(zstdFrames[i].data, decompressedSection),
+                    "Decompression failed!");
+        u32 uncompressedSize = seekTableEntries[i].uncompressedSize;
+        u128 currentSectionSize = std::mem::get_section_size(decompressedSection)
+                                  - previousSectionSize;
+        std::assert_warn(uncompressedSize == currentSectionSize,
+                         std::format("The uncompressedSize {} for ZSTDFrame #{} "
+                                     + "must be equal to its actual decompressed size{}!",
+                                     uncompressedSize, i, currentSectionSize));
+        previousSectionSize += currentSectionSize;
+    };
+
+    Blend<previousSectionSize> blend @ 0x00 in decompressedSection;
+#endif

patterns/bmp.hexpat

@@ -1,6 +1,8 @@
+#pragma description OS2/Windows Bitmap
+
 #pragma MIME image/bmp
 #pragma endian little
-#include <std/mem.pat>
+import std.mem;
 
 struct BitmapFileHeader {
 	u8 bfType[2];
@@ -10,13 +12,38 @@ struct BitmapFileHeader {
 	u32 bfOffBits;
 };
 
-struct BitmapInfoHeader {
+enum Compression : u32 {
+	BI_RGB,
+	BI_RLE8,
+	BI_RLE4,
+	BI_BITFIELDS,
+	BI_JPEG,
+	BI_PNG,
+	BI_ALPHABITFIELDS,
+	BI_CMYK,
+	BI_CMYKRLE8,
+	BI_CMYKRLE4,
+};
+
+struct CIEXYZ {
+	u32 ciexyzX;
+	u32 ciexyzY;
+	u32 ciexyzZ;
+};
+
+struct CIEXYZTRIPLE {
+	CIEXYZ ciexyzRed;
+	CIEXYZ ciexyzGreen;
+	CIEXYZ ciexyzBlue;
+};
+
+struct BitmapInfoHeaderV1 {
 	u32 biSize;
 	s32 biWidth;
 	s32 biHeight;
 	u16 biPlanes;
 	u16 biBitCount;
-	u32 biCompression;
+	Compression biCompression;
 	u32 biSizeImage;
 	s32 biXPelsPerMeter;
 	s32 biYPelsPerMeter;
@@ -24,6 +51,31 @@ struct BitmapInfoHeader {
 	u32 biClrImportant;
 };
 
+struct BitmapInfoHeaderV2 : BitmapInfoHeaderV1 {
+	u32 biRedMask;
+	u32 biGreenMask;
+	u32 biBlueMask;
+};
+
+struct BitmapInfoHeaderV3 : BitmapInfoHeaderV2 {
+	u32 biAlphaMask;
+};
+
+struct BitmapInfoHeaderV4 : BitmapInfoHeaderV3 {
+	u32 biCSType;
+	CIEXYZTRIPLE biEndpoints;
+	u32 biGammaRed;
+	u32 biGammaGreen;
+	u32 biGammaBlue;
+};
+
+struct BitmapInfoHeaderV5 : BitmapInfoHeaderV4 {
+	u32 biIntent;
+	u32 biProfileData;
+	u32 biProfileSize;
+	u32 biReserved;
+};
+
 struct Colors {
 	u8 blue;
 	u8 green;
@@ -32,18 +84,28 @@ struct Colors {
 };
 
 struct Bitmap {
-    u8 data[std::mem::size()] [[no_unique_address, hidden]];
+	u8 data[std::mem::size()] [[no_unique_address, hidden]];
 	BitmapFileHeader bmfh;
-	BitmapInfoHeader bmih;
+	// Deduce the header version from its size
-	
+	u32 bmInfoHeaderSize [[hidden, no_unique_address]];
-	if ((bmih.biBitCount != 24) && (bmih.biBitCount != 32))
+	match (bmInfoHeaderSize) {
+		(40):  BitmapInfoHeaderV1 bmih;
+		(52):  BitmapInfoHeaderV2 bmih;
+		(56):  BitmapInfoHeaderV3 bmih;
+		(108): BitmapInfoHeaderV4 bmih;
+		(124): BitmapInfoHeaderV5 bmih;
+		(_):   BitmapInfoHeaderV1 bmih;
+	}
+	padding[bmih.biSize - sizeof(bmih)];
+
+	if (bmih.biBitCount <= 8)
 	{
 		if (bmih.biClrUsed > 0 )
 			Colors rgbq[bmih.biClrUsed];
 		else
 			Colors rgbq[1 << bmih.biBitCount];
 	}
-	
+
 	if (bmih.biSizeImage > 0 )
 		u8 lineData[bmih.biSizeImage];
 	else

patterns/bplist.hexpat

@@ -0,0 +1,274 @@
+#pragma description Apple binary property list
+#pragma MIME application/x-bplist
+
+import std.math;
+import std.core;
+import type.magic;
+import type.time;
+
+using CFBinaryPlistObject;
+
+enum Marker : u8 {
+    Null  = 0x00,
+    False = 0x08,
+    True = 0x09,
+    Fill = 0x0F,
+    Int = 0x10,
+    Real = 0x20,
+    Date = 0x30,
+    Data = 0x40,
+    ASCIIString = 0x50,
+    Unicode16String = 0x60,
+    UNK_0x70 = 0x70,
+    UID = 0x80,
+    UNK_0x90 = 0x90,
+    Array = 0xA0,
+    UNK_0xB0 = 0xB0,
+    Set = 0xC0,
+    Dict = 0xD0,
+    UNK_0xE0 = 0xE0,
+    UNK_0xF0 = 0xF0
+};
+
+fn get_marker_name(u8 marker) {
+    if (marker == Marker::Null){//    null	0000 0000
+        return "Null ";
+    }else if (marker == Marker::False){ //bool	0000 1000			// false
+        return "False";
+    }else if (marker == Marker::True){//bool	0000 1001			// true
+        return "True";
+    }else if (marker == Marker::Fill){ //fill	0000 1111			// fill byte
+        return "Fill";
+    }else if (marker & 0xF0 == Marker::Int){ //int	0001 nnnn	...		// # of bytes is 2^nnnn, big-endian bytes
+        return "Int";
+    }else if (marker & 0xF0 == Marker:: Real){ //real	0010 nnnn	...		// # of bytes is 2^nnnn, big-endian bytes
+        return "Real";
+    }else if (marker == Marker::Date){ //date	0011 0011	...		// 8 byte float follows, big-endian bytes
+        return "Date";
+    }else if (marker & 0xF0 == Marker::Data){ //data	0100 nnnn	[int]	...	// nnnn is number of bytes unless 1111 then int count follows, followed by bytes
+        return "Data";
+    }else if (marker & 0xF0 == Marker::ASCIIString){ //string	0101 nnnn	[int]	...	// ASCII string, nnnn is # of chars, else 1111 then int count, then bytes
+        return "ASCIIString";
+    }else if (marker & 0xF0 == Marker::Unicode16String){ //string	0110 nnnn	[int]	...	// Unicode string, nnnn is # of chars, else 1111 then int count, then big-endian 2-byte
+        return "Unicode16String";
+    }else if (marker & 0xF0 == Marker::UNK_0x70){ //0111 xxxx			// unused
+        return "UNK_0x70";
+    }else if (marker & 0xF0 == Marker::UID){ //uid	1000 nnnn	...		// nnnn+1 is # of bytes
+        return "UID";
+    }else if (marker & 0xF0 == Marker::UNK_0x90){ // 1001 xxxx			// unused
+        return "UNK_0x90";
+    }else if (marker & 0xF0 == Marker::Array){ //array	1010 nnnn	[int]	objref*	// nnnn is count, unless '1111', then int count follows
+        return "Array";
+    }else if (marker & 0xF0 == Marker::UNK_0xB0){ //1011 xxxx			// unused
+        return "UNK_0xB0";
+    }else if (marker & 0xF0 == Marker::Set){ //set	1100 nnnn	[int]	objref* // nnnn is count, unless '1111', then int count follows
+        return "Set";
+    }else if (marker & 0xF0 == Marker::Dict){ //dict	1101 nnnn	[int]	keyref* objref*	// nnnn is count, unless '1111', then int count follows
+        return "Dict";
+    }else if (marker & 0xF0 == Marker::UNK_0xE0){ // 1110 xxxx			// unused
+        return "UNK_0xE0";
+    }else if (marker & 0xF0 == Marker::UNK_0xF0){  //1111 xxxx			// unused
+        return "UNK_0xF0";
+    }
+};
+
+fn format_tag(u8 marker) {
+    return std::format("{}", get_marker(marker));
+};
+
+fn coredata_to_date (double val){
+    return type::impl::format_time_t(978307200 + val);
+};
+
+struct DictElement {
+    CFBinaryPlistObject key @ offsetTable[parent.objReference.key_refs[std::core::array_index()]].offset;
+    CFBinaryPlistObject value @ offsetTable[parent.objReference.value_refs[std::core::array_index()]].offset;
+};
+
+struct ArrayElement {
+    CFBinaryPlistObject value @ offsetTable[parent.objReference.value_refs[std::core::array_index()]].offset;
+};
+
+struct ObjectReference{
+    match(trailer.objectRefSize){
+        (1): {
+            be u8 key_refs[parent.ObjectLen.size];
+            be u8 value_refs[parent.ObjectLen.size];
+        }
+        (2): {
+            be u16 key_refs[parent.ObjectLen.size];
+            be u16 value_refs[parent.ObjectLen.size];
+        }
+        (4): {
+            be u32 key_refs[parent.ObjectLen.size];
+            be u32 value_refs[parent.ObjectLen.size];
+        }
+        (8): {
+            be u64 key_refs[parent.ObjectLen.size];
+            be u64 value_refs[parent.ObjectLen.size];
+        }
+    }
+};
+
+struct ObjectReferenceArray{
+    match(trailer.objectRefSize){
+        (1): be u8 value_refs[parent.ObjectLen.size];
+        (2): be u16 value_refs[parent.ObjectLen.size];
+        (4): be u32 value_refs[parent.ObjectLen.size];
+        (8): be u64 value_refs[parent.ObjectLen.size];
+    }
+};
+
+struct ObjectLen{
+    if (parent.marker_lsb != 0x0F){
+        u8 size = parent.marker_lsb [[export]];
+    }else{
+        CFBinaryPlistObject obj;
+        if (obj.marker & 0xF0 != Marker::Int){
+            std::error(std::format("Expects a 'Int' marker. Got 0x{:x} marker, with value {}", obj.marker, obj.value));
+        }
+
+        u128 size = obj.value [[export]];
+    }
+};
+
+struct CFBinaryPlistOffset{
+    match (trailer.offsetIntSize){
+        (1): be u8 offset;
+        (2): be u16 offset;
+        (4): be u32 offset;
+        (8): be u64 offset;
+    }
+};
+
+struct CFBinaryPlistObject{
+    u8 marker [[format("get_marker_name")]];
+
+    u8 marker_msb = marker & 0xF0;
+    u8 marker_lsb  = marker & 0x0F;
+
+    match (marker_msb){
+        (0x0): {
+                match (marker_lsb){
+                    (Marker::Null): {
+                        u8 value = 0x00 [[export]];
+                    }
+                    (Marker::False): {
+                        bool value = false [[export]];
+                    }
+                    (Marker::True): {
+                        bool value = true [[export]];
+                    }
+                    (Marker::Fill): {
+                        //I think the correct implementation is to do nothing here. The marker will be used as padding (Fill) ???
+                    }
+                    (_): {
+                        std::error("Detected unknown marker {}.", marker_msb);
+                    }
+                }
+        }
+        (Marker::Int): {
+            be u8 size = std::math::pow(2, marker_lsb);
+            // in format version '00', 1, 2, and 4-byte integers have to be interpreted as unsigned,
+            // whereas 8-byte integers are signed (and 16-byte when available)
+            // negative 1, 2, 4-byte integers are always emitted as 8 bytes in format '00'
+            // integers are not required to be in the most compact possible representation, but only the last 64 bits are significant currently
+            // Source: https://opensource.apple.com/source/CF/CF-550/CFBinaryPList.c
+
+            match (size) {
+                (1): be u8 value;
+                (2): be u16 value;
+                (4): be u32 value;
+                (8): be s64 value;
+                (16): be s128 value;
+                (_): std::error(std::format("Invalid size detected for 'Int' marker. Got size: {}.", size));
+            }
+        }
+        (Marker::Real): {
+            be u8 size = std::math::pow(2, marker_lsb);
+            match (size){
+                (4): be float value;
+                (8): be double value;
+                (_): std::error(std::format("Invalid size detected for 'Real' marker. Got size: {}.", size));
+            }
+        }
+        (Marker::Date): {
+            be double value [[format("coredata_to_date")]];
+        }
+        (Marker::Data): {
+            ObjectLen ObjectLen;
+            u8 value[ObjectLen.size];
+        }
+        (Marker::ASCIIString): {
+            ObjectLen ObjectLen;
+            char value[ObjectLen.size];
+        }
+        (Marker::Unicode16String): {
+           ObjectLen ObjectLen;
+           be char16 value[ObjectLen.size];
+        }
+        (Marker::UID): {
+            //Not 100% sure if this is correct for UID. Need more testing
+            u8 size = marker_lsb+1;
+            match (size) {
+                (1): be u8 value;
+                (2): be u16 value;
+                (4): be u32 value;
+                (8): be u64 value;
+                (16): be u128 value;
+                (_): std::error(std::format("Invalid size detected for 'UID' marker. Got size: {}.", size));
+            }
+        }
+        (Marker::Set | Marker::Array): {
+            ObjectLen ObjectLen;
+
+            ObjectReferenceArray objReference;
+            ArrayElement value[ObjectLen.size];
+        }
+        (Marker::Dict): {
+            ObjectLen ObjectLen;
+
+            ObjectReference objReference;
+            DictElement value[ObjectLen.size];
+        }
+        (Marker::UNK_0x70 | Marker::UNK_0x90 | Marker::UNK_0xB0 | Marker::UNK_0xE0 | Marker::UNK_0xF0): {
+            std::error(std::format("Got unused marker 0x{:x}", marker));
+        }
+        (_): {
+            std::error(std::format("Got unknown marker 0x{:x}", marker));
+        }
+    }
+};
+
+struct CFBinaryPlistHeader{
+    type::Magic<"bplist"> magic;
+    u16 version;
+    if (version != 0x3030){
+        std::error("Unsupported version detected. Only version 00 is supported (bplist00).");
+    }
+};
+
+struct CFBinaryPlistTrailer {
+    u8 unused[5];
+    u8 sortVersion;
+    be u8 offsetIntSize;
+    match (offsetIntSize){
+        (1|2|4|8): {}
+        (_): {std::error("Invalid offsetIntSize.");}
+    }
+    be u8 objectRefSize;
+    match (objectRefSize){
+        (1|2|4|8): {}
+        (_): {std::error("Invalid objectRefSize.");}
+    }
+    be u64 numObjects;
+    be u64 topObject;
+    be u64 offsetTableOffset;
+};
+
+
+CFBinaryPlistHeader header @ 0x00;
+CFBinaryPlistTrailer trailer @ std::mem::size()-32;
+
+CFBinaryPlistOffset offsetTable[trailer.numObjects] @ trailer.offsetTableOffset;
+CFBinaryPlistObject objectTable  @ offsetTable[trailer.topObject].offset;

patterns/bson.hexpat

@@ -1,128 +1,132 @@
-#pragma MIME application/bson
+#pragma author WerWolv
-
+#pragma description BSON (Binary JSON)
-#include <type/time.pat>
+
-
+#pragma MIME application/bson
-enum Type : u8 {
+
-    Double              = 0x01,
+import std.mem;
-    String              = 0x02,
+import type.time;
-    EmbeddedDocument    = 0x03,
+
-    Array               = 0x04,
+enum Type : u8 {
-    Binary              = 0x05,
+    Double              = 0x01,
-    Undefined           = 0x06,
+    String              = 0x02,
-    ObjectId            = 0x07,
+    EmbeddedDocument    = 0x03,
-    Boolean             = 0x08,
+    Array               = 0x04,
-    UTCDatetime         = 0x09,
+    Binary              = 0x05,
-    Null                = 0x0A,
+    Undefined           = 0x06,
-    Regex               = 0x0B,
+    ObjectId            = 0x07,
-    DBPointer           = 0x0C,
+    Boolean             = 0x08,
-    JavaScript          = 0x0D,
+    UTCDatetime         = 0x09,
-    Symbol              = 0x0E,
+    Null                = 0x0A,
-    JavaScriptWithScope = 0x0F,
+    Regex               = 0x0B,
-    Int32               = 0x10,
+    DBPointer           = 0x0C,
-    Timestamp           = 0x11,
+    JavaScript          = 0x0D,
-    Int64               = 0x12,
+    Symbol              = 0x0E,
-    Decimal128          = 0x13,
+    JavaScriptWithScope = 0x0F,
-    
+    Int32               = 0x10,
-    MinKey              = 0xFF, 
+    Timestamp           = 0x11,
-    MaxKey              = 0x7F
+    Int64               = 0x12,
-};
+    Decimal128          = 0x13,
-
+
-enum Subtype : u8 {
+    MinKey              = 0xFF,
-    GenericBinarySubtype   = 0x00,
+    MaxKey              = 0x7F
-    Function               = 0x01,
+};
-    BinaryOld              = 0x02,
+
-    UUIDOld                = 0x03,
+enum Subtype : u8 {
-    UUID                   = 0x04,
+    GenericBinarySubtype   = 0x00,
-    MD5                    = 0x05,
+    Function               = 0x01,
-    EncryptedBSONValue     = 0x06,
+    BinaryOld              = 0x02,
-    CompressedBSONColumn   = 0x07,
+    UUIDOld                = 0x03,
-    UserDefined            = 0x80
+    UUID                   = 0x04,
-};
+    MD5                    = 0x05,
-
+    EncryptedBSONValue     = 0x06,
-struct Binary {
+    CompressedBSONColumn   = 0x07,
-    s32 length;
+    UserDefined            = 0x80
-    Subtype subtype;
+};
-    u8 data[length];
+
-};
+struct Binary {
-
+    s32 length;
-struct String {
+    Subtype subtype;
-    u32 length [[hidden]];
+    u8 data[length];
-    char value[length];
+};
-} [[sealed, format("format_string")]];
+
-
+struct String {
-struct CString {
+    u32 length [[hidden]];
-    char value[];
+    char value[length];
-} [[sealed, format("format_string")]];
+} [[sealed, format("format_string")]];
-
+
-fn format_string(auto string) {
+struct CString {
-    return string.value;
+    char value[];
-};
+} [[sealed, format("format_string")]];
-
+
-struct ObjectId {
+fn format_string(auto string) {
-    type::time32_t timestamp;
+    return string.value;
-    u8 randomValue[5];
+};
-    u24 counter;
+
-};
+struct ObjectId {
-
+    type::time32_t timestamp;
-struct DBPointer {
+    u8 randomValue[5];
-    String name;
+    u24 counter;
-    ObjectId value;
+};
-};
+
-
+struct DBPointer {
-
+    String name;
-using Document;
+    ObjectId value;
-
+};
-struct Element {
+
-    Type type;
+
-    
+using Document;
-    CString name;
+
-    
+struct Element {
-    if (type == Type::Double) {
+    Type type;
-        double value;
+
-    } else if (type == Type::String) {
+    CString name;
-        String value;
+
-    } else if (type == Type::EmbeddedDocument) {
+    if (type == Type::Double) {
-        Document value;
+        double value;
-    } else if (type == Type::Array) {
+    } else if (type == Type::String) {
-        Document value;
+        String value;
-    } else if (type == Type::Binary) {
+    } else if (type == Type::EmbeddedDocument) {
-        Binary value;
+        Document value;
-    } else if (type == Type::Undefined) {
+    } else if (type == Type::Array) {
-        /* undefined */
+        Document value;
-    } else if (type == Type::ObjectId) { 
+    } else if (type == Type::Binary) {
-        ObjectId value;
+        Binary value;
-    } else if (type == Type::Boolean) { 
+    } else if (type == Type::Undefined) {
-        bool value;
+        /* undefined */
-    } else if (type == Type::UTCDatetime) {
+    } else if (type == Type::ObjectId) {
-        type::time64_t value;
+        ObjectId value;
-    } else if (type == Type::Null) {
+    } else if (type == Type::Boolean) {
-        /* null */
+        bool value;
-    } else if (type == Type::Regex) {
+    } else if (type == Type::UTCDatetime) {
-        CString regexPattern;
+        type::time64_t value;
-        CString regexOptions;
+    } else if (type == Type::Null) {
-    } else if (type == Type::DBPointer) {
+        /* null */
-        DBPointer value;
+    } else if (type == Type::Regex) {
-    } else if (type == Type::JavaScript) {
+        CString regexPattern;
-        String value;
+        CString regexOptions;
-    } else if (type == Type::Symbol) {
+    } else if (type == Type::DBPointer) {
-        String value;
+        DBPointer value;
-    } else if (type == Type::JavaScriptWithScope) {
+    } else if (type == Type::JavaScript) {
-        String value;
+        String value;
-    } else if (type == Type::Int32) {
+    } else if (type == Type::Symbol) {
-        s32 value;
+        String value;
-    } else if (type == Type::Timestamp) {
+    } else if (type == Type::JavaScriptWithScope) {
-        u64 value;
+        String value;
-    } else if (type == Type::Int64) {
+    } else if (type == Type::Int32) {
-        s64 value;
+        s32 value;
-    } else if (type == Type::Decimal128) {
+    } else if (type == Type::Timestamp) {
-        u128 value;
+        u64 value;
-    }
+    } else if (type == Type::Int64) {
-};
+        s64 value;
-
+    } else if (type == Type::Decimal128) {
-struct Document {
+        u128 value;
-    s32 listLength;
+    }
-    Element elements[while($ < ((addressof(this) + listLength) - 1))];
+};
-    padding[1];
+
-};
+struct Document {
-
+    s32 listLength;
-Document document @ 0x00;
+    Element elements[while($ < ((addressof(this) + listLength) - 1))];
+    padding[1];
+};
+
+Document documents[while(!std::mem::eof())] @ 0x00 [[inline]];

patterns/bsp_goldsrc.hexpat

@@ -1,6 +1,8 @@
-#include <std/ptr.pat>
+#pragma description GoldSrc engine map (Half-Life 1)
-#include <std/mem.pat>
+
-#include <std/sys.pat>
+import std.ptr;
+import std.mem;
+import std.sys;
 
 #pragma endian little
 
@@ -161,7 +163,7 @@ struct dmiptexlump_t
 	MiptexPointer dataofs[nummiptex];
 };
 
-struct VisibilityData 
+struct VisibilityData
 {
 	u8 data[file_header.lumps[LumpIndex::Visibility].filelen];
 	u8 pad[std::mem::align_to(4, sizeof(this)) - sizeof(this)];

patterns/bzip3.hexpat

@@ -0,0 +1,64 @@
+#pragma author Sewer56
+#pragma description Parses BZip3 compression (file format) by Kamila Szewczyk
+#pragma MIME application/x-bzip3
+#pragma endian little
+#pragma magic [42 5A 33 76 31] @ 0x00
+import std.mem;
+
+// Helper function for bit counting
+fn popcount(u8 b) {
+    u32 count = 0;
+    while (b != 0) {
+        count = count + (b & 1);
+        b = b >> 1;
+    }
+    return count;
+};
+
+// Frame header structure
+struct FrameHeader {
+    char magic[5];         // "BZ3v1"
+    u32 blockSize;         // Maximum block size
+};
+
+// Small block header (for blocks < 64 bytes)
+struct SmallBlock {
+    u32 crc32;           // CRC32 checksum
+    u32 literal;         // Always 0xFFFFFFFF for small blocks
+    u8 data[parent.compressedSize - 8]; // Uncompressed data
+};
+
+// Regular block (blocks > 64 bytes)
+struct Block {
+    u32 crc32;            // CRC32 checksum of uncompressed data
+    u32 bwtIndex;         // Burrows-Wheeler transform index
+    u8  model;            // Compression model flags
+    
+    if ((model & 0x02) != 0)     
+        u32 lzpSize;      // Size after LZP compression
+    if ((model & 0x04) != 0)     
+        u32 rleSize;      // Size after RLE compression
+        
+    u8 data[parent.compressedSize - (popcount(model) * 4 + 9)];
+};
+
+// Main block structure
+struct Chunk {
+    u32 compressedSize;   // Size of compressed block
+    u32 origSize;         // Original uncompressed size
+        
+    if (origSize < 64) {
+        SmallBlock block;
+    } else {
+        Block block;
+    }
+};
+
+// Main parsing structure
+struct BZip3File {
+    FrameHeader header;
+    // Read blocks until end of file
+    Chunk chunks[while(!std::mem::eof())];
+};
+
+BZip3File file @ 0x0;

patterns/cab.hexpat

@@ -0,0 +1,110 @@
+#pragma author The Wandering Trader
+#pragma description Microsoft Cabinet (CAB) Files
+#pragma magic [4D 53 43 46] @ 0x00
+
+import type.time;
+import type.magic;
+import type.size;
+
+fn format_string(auto string) {
+    return std::format("{}",string);
+};
+
+bitfield flags {
+    bool cfhdrPREV_CABINET : 1;
+    bool cfhdrNEXT_CABINET : 1;
+    bool cfhdrRESERVE_PRESENT : 1;
+    padding : 13;
+};
+
+struct CFHEADER {
+    type::Magic<"MSCF"> signature;
+    u32 reserved1;
+    type::Size32 cbCabinet;
+    u32 reserved2;
+    u32 coffFiles;
+    u32 reserved3;
+    u8 versionMajor;
+    u8 versionMinor;
+    u16 cFolders;
+    u16 cFiles;
+    flags flags;
+    u16 setID;
+    u16 iCabinet;
+    if (flags.cfhdrRESERVE_PRESENT) {
+        type::Size16 cbCFHeader;
+        type::Size8 cbCFFolder;
+        type::Size8  cbCFData;
+        u8 abReserve[cbCFHeader];
+    }
+    if (flags.cfhdrPREV_CABINET) {
+        char szCabinetPrev[] [[format("format_string")]];
+        char szDiskPrev[] [[format("format_string")]];
+    }
+    if (flags.cfhdrNEXT_CABINET) {
+        char szCabinetNext[] [[format("format_string")]];
+        char szDiskNext[] [[format("format_string")]];
+    }
+};
+
+enum typeCompress : u8{
+    tcompMASK_TYPE = 0x000F,
+    tcompTYPE_NONE = 0x0000,
+    tcompTYPE_MSZIP = 0x0001,
+    tcompTYPE_QUANTUM = 0x0002,
+    tcompTYPE_LZX = 0x0003,
+};
+
+using CFDATA;
+
+struct CFFOLDER {
+    u32 coffCabStart;
+    u16 cCfData;
+    typeCompress typeCompress;
+    u8 compressionLevel;
+    if (CFHEADER.flags.cfhdrRESERVE_PRESENT) {
+        u8 abReserve[CFHEADER.cbCFFolder];
+    }
+    CFDATA CFDATA[cCfData] @ coffCabStart;
+};
+
+bitfield attribs {
+    bool _A_RDONLY : 1;
+    bool _A_HIDDEN : 1;
+    bool _A_SYSTEM : 1;
+    padding : 2;
+    bool _A_ARCH : 1;
+    bool _A_EXEC : 1;
+    bool _A_NAME_IS_UTF : 1;
+    padding : 8;
+};
+
+struct CFFILE {
+    type::Size32 cbFile;
+    u32 uoffFolderStart;
+    u16 iFolder;
+    type::DOSDate date;
+    type::DOSTime time;
+    attribs attribs;
+    if (attribs._A_NAME_IS_UTF) {
+        char16 szName[];
+    } else {
+        char szName[] [[format("format_string")]];
+    }
+    
+    
+};
+
+struct CFDATA {
+    u32 csum;
+    type::Size16 cbData;
+    type::Size16 cbUncomp;
+    if (CFHEADER.flags.cfhdrRESERVE_PRESENT) {
+        u8 abReserve[CFHEADER.cbCFData];
+    }
+    u8 ab[cbData];
+};
+
+CFHEADER CFHEADER @ 0;
+CFFOLDER CFFOLDER[CFHEADER.cFolders] @ $;
+CFFILE CFFILE[CFHEADER.cFiles] @ $;

patterns/cchva.hexpat

@@ -1,3 +1,5 @@
+#pragma description Command and Conquer Voxel Animation
+
 // Command and conquer voxel animation format
 
 struct vec4_s {

patterns/ccpal.hexpat

@@ -1,3 +1,5 @@
+#pragma description Command and Conquer Voxel Palette
+
 // Command and conquer palette format
 
 struct Color {

patterns/ccvxl.hexpat

@@ -1,3 +1,5 @@
+#pragma description Command and Conquer Voxel Model
+
 // Command and Conquer voxel model format
 
 struct vec4_s {

patterns/cda.hexpat

@@ -1,27 +1,29 @@
+#pragma description Compact Disc Audio track
+#pragma magic [ 52 49 46 46 ] @ 0x00
+
 struct Header {
-u32 RIFF;
+    u32 RIFF;
-s32 size;
+    s32 size;
-u32 CDDA;
+    u32 CDDA;
-u32 fmt;
+    u32 fmt;
-u32 lenghtofthechunck;
+    u32 lenghtofthechunck;
-u16 versionofcdformat;
+    u16 versionofcdformat;
-u16 numberofrange;
+    u16 numberofrange;
-u32 identifier;
+    u32 identifier;
 };
 
 
 struct DataInfo {
-
+    u32 range;
-u32 range;
+    u32 duration;
-u32 duration;
+    u8 rangepositionframes;
-u8 rangepositionframes;
+    u8 rangepositionseconds;
-u8 rangepositionseconds;
+    u8 rangepositionminutes;
-u8 rangepositionminutes;
+    u8 nullbyte;
-u8 nullbyte;
+    u8 durationtrackframes;
-u8 durationtrackframes;
+    u8 durationtrackseconds;
-u8 durationtrackseconds;
+    u8 durationtrackminutes;
-u8 durationtrackminutes;
+    u8 nullbytee;
-u8 nullbytee;
 };
 
 

patterns/chd.hexpat

@@ -0,0 +1,105 @@
+#pragma author Lexi Mayfield
+#pragma description MAME Compressed Hunks of Data
+#pragma endian big
+
+fn CHD_MAKE_TAG(char a, char b, char c, char d) {
+    return (u32(u8(a)) << 24) |
+           u32(u8((b)) << 16) |
+           u32(u8((c)) << 8) |
+            u32(u8(d));
+};
+
+enum CHDv5_CODEC : u32 {
+    NONE = 0,
+    ZLIB = CHD_MAKE_TAG('z','l','i','b'),
+    ZSTD = CHD_MAKE_TAG('z','s','t','d'),
+    LZMA = CHD_MAKE_TAG('l','z','m','a'),
+    HUFFMAN = CHD_MAKE_TAG('h','u','f','f'),
+    FLAC = CHD_MAKE_TAG('f','l','a','c'),
+    CD_ZLIB = CHD_MAKE_TAG('c','d','z','l'),
+    CD_ZSTD = CHD_MAKE_TAG('c','d','z','s'),
+    CD_LZMA = CHD_MAKE_TAG('c','d','l','z'),
+    CD_FLAC = CHD_MAKE_TAG('c','d','f','l'),
+    AVHUFF = CHD_MAKE_TAG('a','v','h','u'),
+};
+
+enum CHDv5_METADATA_TAG : u32 {
+    CHDMETATAG_WILDCARD = 0,
+    HARD_DISK_METADATA_TAG = CHD_MAKE_TAG('G','D','D','D'),
+    HARD_DISK_IDENT_METADATA_TAG = CHD_MAKE_TAG('I','D','N','T'),
+    HARD_DISK_KEY_METADATA_TAG = CHD_MAKE_TAG('K','E','Y',' '),
+    PCMCIA_CIS_METADATA_TAG = CHD_MAKE_TAG('C','I','S',' '),
+    CDROM_OLD_METADATA_TAG = CHD_MAKE_TAG('C','H','C','D'),
+    CDROM_TRACK_METADATA_TAG = CHD_MAKE_TAG('C','H','T','R'),
+    CDROM_TRACK_METADATA2_TAG = CHD_MAKE_TAG('C','H','T','2'),
+    GDROM_OLD_METADATA_TAG = CHD_MAKE_TAG('C','H','G','T'),
+    GDROM_TRACK_METADATA_TAG = CHD_MAKE_TAG('C','H','G','D'),
+    DVD_METADATA_TAG = CHD_MAKE_TAG('D','V','D',' '),
+    AV_METADATA_TAG = CHD_MAKE_TAG('A','V','A','V'),
+    AV_LD_METADATA_TAG = CHD_MAKE_TAG('A','V','L','D'),
+};
+
+struct CHDv5UncompressedMap {
+    u32 offset;
+};
+
+struct CHDv5CompressedMapEntry {
+    u8 compression;
+    u24 complength;
+    u48 offset;
+    u16 crc;
+};
+
+struct CHDv5CompressedMap {
+    u32 length;
+    u48 datastart;
+    u16 crc;
+    u8 lengthbits;
+    u8 hunkbits;
+    u8 parentunitbits;
+    u8 reserved;
+};
+
+struct CHDv5MetadataEntry {
+    CHDv5_METADATA_TAG metatag;
+    u8 flags;
+    u24 length;
+    u64 next;    
+    char entry[length];
+    
+    if (next != 0) {
+        CHDv5MetadataEntry nextMeta @ next;
+    }
+};
+
+struct CHDv5 {
+    CHDv5_CODEC compressors[4];
+    u64 logicalbytes;
+    u64 mapoffset;
+    u64 metaoffset;
+    u32 hunkbytes;
+    u32 unitbytes;
+    u8 rawsha1[20];
+    u8 sha1[20];
+    u8 parentsha1[20];
+    
+    if (compressors[0] == CHDv5_CODEC::NONE) {
+        CHDv5UncompressedMap map @ mapoffset;
+    } else {
+        CHDv5CompressedMap map @ mapoffset;
+    }
+    
+    CHDv5MetadataEntry meta @ metaoffset;
+};
+
+struct CHD {
+    char tag[8];
+    u32 length;
+    u32 version;
+    
+    if (version == 5) {
+        CHDv5 chd;
+    }
+};
+
+CHD chd @ 0x00;

patterns/chm.hexpat

@@ -1,395 +1,399 @@
-#include <type/magic.pat>
+#pragma author WerWolv
-#include <type/size.pat>
+#pragma description Windows HtmlHelp Data (ITSF / CHM)
-#include <type/guid.pat>
+#pragma MIME application/vnd.ms-htmlhelp
-#include <type/leb128.pat>
+
-#include <std/sys.pat>
+import type.magic;
-
+import type.size;
-enum WindowsLanguageId : u32 {
+import type.guid;
-    Arabic_SaudiArabia                          = 0x401,
+import type.leb128;
-    Arabic_Iraq                                 = 0x801,
+import std.sys;
-    Arabic_Egypt                                = 0xc01,
+
-    Arabic_Libya                                = 0x1001,
+enum WindowsLanguageId : u32 {
-    Arabic_Algeria                              = 0x1401,
+    Arabic_SaudiArabia                          = 0x401,
-    Arabic_Morocco                              = 0x1801,
+    Arabic_Iraq                                 = 0x801,
-    Arabic_Tunisia                              = 0x1c01,
+    Arabic_Egypt                                = 0xc01,
-    Arabic_Oman                                 = 0x2001,
+    Arabic_Libya                                = 0x1001,
-    Arabic_Yemen                                = 0x2401,
+    Arabic_Algeria                              = 0x1401,
-    Arabic_Syria                                = 0x2801,
+    Arabic_Morocco                              = 0x1801,
-    Arabic_Jordan                               = 0x2c01,
+    Arabic_Tunisia                              = 0x1c01,
-    Arabic_Lebanon                              = 0x3001,
+    Arabic_Oman                                 = 0x2001,
-    Arabic_Kuwait                               = 0x3401,
+    Arabic_Yemen                                = 0x2401,
-    Arabic_UAE                                  = 0x3801,
+    Arabic_Syria                                = 0x2801,
-    Arabic_Bahrain                              = 0x3c01,
+    Arabic_Jordan                               = 0x2c01,
-    Arabic_Qatar                                = 0x4001,
+    Arabic_Lebanon                              = 0x3001,
-    Bulgarian                                   = 0x402,
+    Arabic_Kuwait                               = 0x3401,
-    Catalan                                     = 0x403,
+    Arabic_UAE                                  = 0x3801,
-    Valencian                                   = 0x803,
+    Arabic_Bahrain                              = 0x3c01,
-    Chinese_Taiwan                              = 0x404,
+    Arabic_Qatar                                = 0x4001,
-    Chinese_PRC                                 = 0x804,
+    Bulgarian                                   = 0x402,
-    Chinese_HongKongSAR                         = 0xc04,
+    Catalan                                     = 0x403,
-    Chinese_Singapore                           = 0x1004,
+    Valencian                                   = 0x803,
-    Chinese_MacaoSAR                            = 0x1404,
+    Chinese_Taiwan                              = 0x404,
-    Czech                                       = 0x405,
+    Chinese_PRC                                 = 0x804,
-    Danish                                      = 0x406,
+    Chinese_HongKongSAR                         = 0xc04,
-    German_Germany                              = 0x407,
+    Chinese_Singapore                           = 0x1004,
-    German_Switzerland                          = 0x807,
+    Chinese_MacaoSAR                            = 0x1404,
-    German_Austria                              = 0xc07,
+    Czech                                       = 0x405,
-    German_Luxembourg                           = 0x1007,
+    Danish                                      = 0x406,
-    German_Liechtenstein                        = 0x1407,
+    German_Germany                              = 0x407,
-    Greek                                       = 0x408,
+    German_Switzerland                          = 0x807,
-    English_UnitedStates                        = 0x409,
+    German_Austria                              = 0xc07,
-    English_UnitedKingdom                       = 0x809,
+    German_Luxembourg                           = 0x1007,
-    English_Australia                           = 0xc09,
+    German_Liechtenstein                        = 0x1407,
-    English_Canada                              = 0x1009,
+    Greek                                       = 0x408,
-    English_NewZealand                          = 0x1409,
+    English_UnitedStates                        = 0x409,
-    English_Ireland                             = 0x1809,
+    English_UnitedKingdom                       = 0x809,
-    English_SouthAfrica                         = 0x1c09,
+    English_Australia                           = 0xc09,
-    English_Jamaica                             = 0x2009,
+    English_Canada                              = 0x1009,
-    English_Caribbean                           = 0x2409,
+    English_NewZealand                          = 0x1409,
-    English_Belize                              = 0x2809,
+    English_Ireland                             = 0x1809,
-    English_TrinidadandTobago                   = 0x2c09,
+    English_SouthAfrica                         = 0x1c09,
-    English_Zimbabwe                            = 0x3009,
+    English_Jamaica                             = 0x2009,
-    English_Philippines                         = 0x3409,
+    English_Caribbean                           = 0x2409,
-    English_Indonesia                           = 0x3809,
+    English_Belize                              = 0x2809,
-    English_HongKongSAR                         = 0x3c09,
+    English_TrinidadandTobago                   = 0x2c09,
-    English_India                               = 0x4009,
+    English_Zimbabwe                            = 0x3009,
-    English_Malaysia                            = 0x4409,
+    English_Philippines                         = 0x3409,
-    English_Singapore                           = 0x4809,
+    English_Indonesia                           = 0x3809,
-    Spanish_SpainTraditionalSort                = 0x40a,
+    English_HongKongSAR                         = 0x3c09,
-    Spanish_Mexico                              = 0x80a,
+    English_India                               = 0x4009,
-    Spanish_Spain                               = 0xc0a,
+    English_Malaysia                            = 0x4409,
-    Spanish_Guatemala                           = 0x100a,
+    English_Singapore                           = 0x4809,
-    Spanish_CostaRica                           = 0x140a,
+    Spanish_SpainTraditionalSort                = 0x40a,
-    Spanish_Panama                              = 0x180a,
+    Spanish_Mexico                              = 0x80a,
-    Spanish_DominicanRepublic                   = 0x1c0a,
+    Spanish_Spain                               = 0xc0a,
-    Spanish_Venezuela                           = 0x200a,
+    Spanish_Guatemala                           = 0x100a,
-    Spanish_Colombia                            = 0x240a,
+    Spanish_CostaRica                           = 0x140a,
-    Spanish_Peru                                = 0x280a,
+    Spanish_Panama                              = 0x180a,
-    Spanish_Argentina                           = 0x2c0a,
+    Spanish_DominicanRepublic                   = 0x1c0a,
-    Spanish_Ecuador                             = 0x300a,
+    Spanish_Venezuela                           = 0x200a,
-    Spanish_Chile                               = 0x340a,
+    Spanish_Colombia                            = 0x240a,
-    Spanish_Uruguay                             = 0x380a,
+    Spanish_Peru                                = 0x280a,
-    Spanish_Paraguay                            = 0x3c0a,
+    Spanish_Argentina                           = 0x2c0a,
-    Spanish_Bolivia                             = 0x400a,
+    Spanish_Ecuador                             = 0x300a,
-    Spanish_ElSalvador                          = 0x440a,
+    Spanish_Chile                               = 0x340a,
-    Spanish_Honduras                            = 0x480a,
+    Spanish_Uruguay                             = 0x380a,
-    Spanish_Nicaragua                           = 0x4c0a,
+    Spanish_Paraguay                            = 0x3c0a,
-    Spanish_PuertoRico                          = 0x500a,
+    Spanish_Bolivia                             = 0x400a,
-    Spanish_UnitedStates                        = 0x540a,
+    Spanish_ElSalvador                          = 0x440a,
-    Spanish_LatinAmerica                        = 0x580a,
+    Spanish_Honduras                            = 0x480a,
-    Finnish                                     = 0x40b,
+    Spanish_Nicaragua                           = 0x4c0a,
-    French_France                               = 0x40c,
+    Spanish_PuertoRico                          = 0x500a,
-    French_Belgium                              = 0x80c,
+    Spanish_UnitedStates                        = 0x540a,
-    French_Canada                               = 0xc0c,
+    Spanish_LatinAmerica                        = 0x580a,
-    French_Switzerland                          = 0x100c,
+    Finnish                                     = 0x40b,
-    French_Luxembourg                           = 0x140c,
+    French_France                               = 0x40c,
-    French_Monaco                               = 0x180c,
+    French_Belgium                              = 0x80c,
-    French_Caribbean                            = 0x1c0c,
+    French_Canada                               = 0xc0c,
-    French_Reunion                              = 0x200c,
+    French_Switzerland                          = 0x100c,
-    French_CongoDRC                             = 0x240c,
+    French_Luxembourg                           = 0x140c,
-    French_Senegal                              = 0x280c,
+    French_Monaco                               = 0x180c,
-    French_Cameroon                             = 0x2c0c,
+    French_Caribbean                            = 0x1c0c,
-    French_CoteDIvoire                          = 0x300c,
+    French_Reunion                              = 0x200c,
-    French_Mali                                 = 0x340c,
+    French_CongoDRC                             = 0x240c,
-    French_Morocco                              = 0x380c,
+    French_Senegal                              = 0x280c,
-    French_Haiti                                = 0x3c0c,
+    French_Cameroon                             = 0x2c0c,
-    Hebrew                                      = 0x40d,
+    French_CoteDIvoire                          = 0x300c,
-    Hungarian                                   = 0x40e,
+    French_Mali                                 = 0x340c,
-    Icelandic                                   = 0x40f,
+    French_Morocco                              = 0x380c,
-    Italian_Italy                               = 0x410,
+    French_Haiti                                = 0x3c0c,
-    Italian_Switzerland                         = 0x810,
+    Hebrew                                      = 0x40d,
-    Japanese                                    = 0x411,
+    Hungarian                                   = 0x40e,
-    Korean                                      = 0x412,
+    Icelandic                                   = 0x40f,
-    Dutch_Netherlands                           = 0x413,
+    Italian_Italy                               = 0x410,
-    Dutch_Belgium                               = 0x813,
+    Italian_Switzerland                         = 0x810,
-    Norwegian_Bokmal                            = 0x414,
+    Japanese                                    = 0x411,
-    Norwegian_Nynorsk                           = 0x814,
+    Korean                                      = 0x412,
-    Polish                                      = 0x415,
+    Dutch_Netherlands                           = 0x413,
-    Portuguese_Brazil                           = 0x416,
+    Dutch_Belgium                               = 0x813,
-    Portuguese_Portugal                         = 0x816,
+    Norwegian_Bokmal                            = 0x414,
-    Romansh                                     = 0x417,
+    Norwegian_Nynorsk                           = 0x814,
-    Romanian                                    = 0x418,
+    Polish                                      = 0x415,
-    Romanian_Moldova                            = 0x818,
+    Portuguese_Brazil                           = 0x416,
-    Russian                                     = 0x419,
+    Portuguese_Portugal                         = 0x816,
-    Russian_Moldova                             = 0x819,
+    Romansh                                     = 0x417,
-    Croatian_Croatia                            = 0x41a,
+    Romanian                                    = 0x418,
-    Serbian_LatinSerbiaandMontenegroFormer      = 0x81a,
+    Romanian_Moldova                            = 0x818,
-    Serbian_CyrillicSerbiaAndMontenegroFormer   = 0xc1a,
+    Russian                                     = 0x419,
-    Croatian_BosniaAndHerzegovina               = 0x101a,
+    Russian_Moldova                             = 0x819,
-    Bosnian_Latin                               = 0x141a,
+    Croatian_Croatia                            = 0x41a,
-    Serbian_LatinBosniaAndHerzegovina           = 0x181a,
+    Serbian_LatinSerbiaandMontenegroFormer      = 0x81a,
-    Serbian_CyrillicBosniaAndHerzegovina        = 0x1c1a,
+    Serbian_CyrillicSerbiaAndMontenegroFormer   = 0xc1a,
-    Bosnian_Cyrillic                            = 0x201a,
+    Croatian_BosniaAndHerzegovina               = 0x101a,
-    Serbian_LatinSerbia                         = 0x241a,
+    Bosnian_Latin                               = 0x141a,
-    Serbian_CyrillicSerbia                      = 0x281a,
+    Serbian_LatinBosniaAndHerzegovina           = 0x181a,
-    Serbian_LatinMontenegro                     = 0x2c1a,
+    Serbian_CyrillicBosniaAndHerzegovina        = 0x1c1a,
-    Serbian_CyrillicMontenegro                  = 0x301a,
+    Bosnian_Cyrillic                            = 0x201a,
-    Slovak                                      = 0x41b,
+    Serbian_LatinSerbia                         = 0x241a,
-    Albanian                                    = 0x41c,
+    Serbian_CyrillicSerbia                      = 0x281a,
-    Swedish_Sweden                              = 0x41d,
+    Serbian_LatinMontenegro                     = 0x2c1a,
-    Swedish_Finland                             = 0x81d,
+    Serbian_CyrillicMontenegro                  = 0x301a,
-    Thai                                        = 0x41e,
+    Slovak                                      = 0x41b,
-    Turkish                                     = 0x41f,
+    Albanian                                    = 0x41c,
-    Urdu_Pakistan                               = 0x420,
+    Swedish_Sweden                              = 0x41d,
-    Urdu_India                                  = 0x820,
+    Swedish_Finland                             = 0x81d,
-    Indonesian                                  = 0x421,
+    Thai                                        = 0x41e,
-    Ukrainian                                   = 0x422,
+    Turkish                                     = 0x41f,
-    Belarusian                                  = 0x423,
+    Urdu_Pakistan                               = 0x420,
-    Slovenian                                   = 0x424,
+    Urdu_India                                  = 0x820,
-    Estonian                                    = 0x425,
+    Indonesian                                  = 0x421,
-    Latvian                                     = 0x426,
+    Ukrainian                                   = 0x422,
-    Lithuanian                                  = 0x427,
+    Belarusian                                  = 0x423,
-    Tajik                                       = 0x428,
+    Slovenian                                   = 0x424,
-    Persian                                     = 0x429,
+    Estonian                                    = 0x425,
-    Vietnamese                                  = 0x42a,
+    Latvian                                     = 0x426,
-    Armenian                                    = 0x42b,
+    Lithuanian                                  = 0x427,
-    Azerbaijani_Latin                           = 0x42c,
+    Tajik                                       = 0x428,
-    Azerbaijani_Cyrillic                        = 0x82c,
+    Persian                                     = 0x429,
-    Basque                                      = 0x42d,
+    Vietnamese                                  = 0x42a,
-    UpperSorbian                                = 0x42e,
+    Armenian                                    = 0x42b,
-    LowerSorbian                                = 0x82e,
+    Azerbaijani_Latin                           = 0x42c,
-    Macedonian                                  = 0x42f,
+    Azerbaijani_Cyrillic                        = 0x82c,
-    Sesotho_SouthAfrica                         = 0x430,
+    Basque                                      = 0x42d,
-    Xitsonga                                    = 0x431,
+    UpperSorbian                                = 0x42e,
-    Setswana_SouthAfrica                        = 0x432,
+    LowerSorbian                                = 0x82e,
-    Setswana_Botswana                           = 0x832,
+    Macedonian                                  = 0x42f,
-    Venda                                       = 0x433,
+    Sesotho_SouthAfrica                         = 0x430,
-    isiXhosa                                    = 0x434,
+    Xitsonga                                    = 0x431,
-    isiZulu                                     = 0x435,
+    Setswana_SouthAfrica                        = 0x432,
-    Afrikaans                                   = 0x436,
+    Setswana_Botswana                           = 0x832,
-    Georgian                                    = 0x437,
+    Venda                                       = 0x433,
-    Faroese                                     = 0x438,
+    isiXhosa                                    = 0x434,
-    Hindi                                       = 0x439,
+    isiZulu                                     = 0x435,
-    Maltese                                     = 0x43a,
+    Afrikaans                                   = 0x436,
-    NorthernSami_Norway                         = 0x43b,
+    Georgian                                    = 0x437,
-    NorthernSami_Sweden                         = 0x83b,
+    Faroese                                     = 0x438,
-    NorthernSami_Finland                        = 0xc3b,
+    Hindi                                       = 0x439,
-    LuleSami_Norway                             = 0x103b,
+    Maltese                                     = 0x43a,
-    LuleSami_Sweden                             = 0x143b,
+    NorthernSami_Norway                         = 0x43b,
-    SouthernSami_Norway                         = 0x183b,
+    NorthernSami_Sweden                         = 0x83b,
-    SouthernSami_Sweden                         = 0x1c3b,
+    NorthernSami_Finland                        = 0xc3b,
-    SkoltSami_Finland                           = 0x203b,
+    LuleSami_Norway                             = 0x103b,
-    InariSami_Finland                           = 0x243b,
+    LuleSami_Sweden                             = 0x143b,
-    Irish                                       = 0x83c,
+    SouthernSami_Norway                         = 0x183b,
-    Yiddish                                     = 0x43d,
+    SouthernSami_Sweden                         = 0x1c3b,
-    Malay_Malaysia                              = 0x43e,
+    SkoltSami_Finland                           = 0x203b,
-    Malay_BruneiDarussalam                      = 0x83e,
+    InariSami_Finland                           = 0x243b,
-    Kazakh                                      = 0x43f,
+    Irish                                       = 0x83c,
-    Kyrgyz                                      = 0x440,
+    Yiddish                                     = 0x43d,
-    Kiswahili                                   = 0x441,
+    Malay_Malaysia                              = 0x43e,
-    Turkmen                                     = 0x442,
+    Malay_BruneiDarussalam                      = 0x83e,
-    Uzbek_Latin                                 = 0x443,
+    Kazakh                                      = 0x43f,
-    Uzbek_Cyrillic                              = 0x843,
+    Kyrgyz                                      = 0x440,
-    Tatar                                       = 0x444,
+    Kiswahili                                   = 0x441,
-    Bangla_India                                = 0x445,
+    Turkmen                                     = 0x442,
-    Bangla_Bangladesh                           = 0x845,
+    Uzbek_Latin                                 = 0x443,
-    Punjabi_India                               = 0x446,
+    Uzbek_Cyrillic                              = 0x843,
-    Punjabi_Pakistan                            = 0x846,
+    Tatar                                       = 0x444,
-    Gujarati                                    = 0x447,
+    Bangla_India                                = 0x445,
-    Odia                                        = 0x448,
+    Bangla_Bangladesh                           = 0x845,
-    Tamil_India                                 = 0x449,
+    Punjabi_India                               = 0x446,
-    Tamil_SriLanka                              = 0x849,
+    Punjabi_Pakistan                            = 0x846,
-    Telugu                                      = 0x44a,
+    Gujarati                                    = 0x447,
-    Kannada                                     = 0x44b,
+    Odia                                        = 0x448,
-    Malayalam                                   = 0x44c,
+    Tamil_India                                 = 0x449,
-    Assamese                                    = 0x44d,
+    Tamil_SriLanka                              = 0x849,
-    Marathi                                     = 0x44e,
+    Telugu                                      = 0x44a,
-    Sanskrit                                    = 0x44f,
+    Kannada                                     = 0x44b,
-    Mongolian_Cyrillic                          = 0x450,
+    Malayalam                                   = 0x44c,
-    Mongolian_TraditionalMongolianPRC           = 0x850,
+    Assamese                                    = 0x44d,
-    Mongolian_TraditionalMongolianMongolia      = 0xc50,
+    Marathi                                     = 0x44e,
-    Tibetan_PRC                                 = 0x451,
+    Sanskrit                                    = 0x44f,
-    Welsh                                       = 0x452,
+    Mongolian_Cyrillic                          = 0x450,
-    Khmer                                       = 0x453,
+    Mongolian_TraditionalMongolianPRC           = 0x850,
-    Lao                                         = 0x454,
+    Mongolian_TraditionalMongolianMongolia      = 0xc50,
-    Burmese                                     = 0x455,
+    Tibetan_PRC                                 = 0x451,
-    Galician                                    = 0x456,
+    Welsh                                       = 0x452,
-    Konkani                                     = 0x457,
+    Khmer                                       = 0x453,
-    Manipuri                                    = 0x458,
+    Lao                                         = 0x454,
-    Sindhi_Devanagari                           = 0x459,
+    Burmese                                     = 0x455,
-    Sindhi_Arabic                               = 0x859,
+    Galician                                    = 0x456,
-    Syriac                                      = 0x45a,
+    Konkani                                     = 0x457,
-    Sinhala                                     = 0x45b,
+    Manipuri                                    = 0x458,
-    Cherokee_Cherokee                           = 0x45c,
+    Sindhi_Devanagari                           = 0x459,
-    Inuktitut_Syllabics                         = 0x45d,
+    Sindhi_Arabic                               = 0x859,
-    Inuktitut_Latin                             = 0x85d,
+    Syriac                                      = 0x45a,
-    Amharic                                     = 0x45e,
+    Sinhala                                     = 0x45b,
-    Tamazight_ArabicMorocco                     = 0x45f,
+    Cherokee_Cherokee                           = 0x45c,
-    Tamazight_LatinAlgeria                      = 0x85f,
+    Inuktitut_Syllabics                         = 0x45d,
-    Tamazight_TifinaghMorocco                   = 0x105f,
+    Inuktitut_Latin                             = 0x85d,
-    Kashmiri_Arabic                             = 0x460,
+    Amharic                                     = 0x45e,
-    Kashmiri                                    = 0x860,
+    Tamazight_ArabicMorocco                     = 0x45f,
-    Nepali                                      = 0x461,
+    Tamazight_LatinAlgeria                      = 0x85f,
-    Nepali_India                                = 0x861,
+    Tamazight_TifinaghMorocco                   = 0x105f,
-    Frisian                                     = 0x462,
+    Kashmiri_Arabic                             = 0x460,
-    Pashto                                      = 0x463,
+    Kashmiri                                    = 0x860,
-    Filipino                                    = 0x464,
+    Nepali                                      = 0x461,
-    Divehi                                      = 0x465,
+    Nepali_India                                = 0x861,
-    Edo                                         = 0x466,
+    Frisian                                     = 0x462,
-    Fulah_Nigeria                               = 0x467,
+    Pashto                                      = 0x463,
-    Fulah_LatinSenegal                          = 0x867,
+    Filipino                                    = 0x464,
-    Hausa                                       = 0x468,
+    Divehi                                      = 0x465,
-    Ibibio_Nigeria                              = 0x469,
+    Edo                                         = 0x466,
-    Yoruba                                      = 0x46a,
+    Fulah_Nigeria                               = 0x467,
-    Quechua_Bolivia                             = 0x46b,
+    Fulah_LatinSenegal                          = 0x867,
-    Quechua_Ecuador                             = 0x86b,
+    Hausa                                       = 0x468,
-    Quechua_Peru                                = 0xc6b,
+    Ibibio_Nigeria                              = 0x469,
-    SesothoSaLeboa                              = 0x46c,
+    Yoruba                                      = 0x46a,
-    Bashkir                                     = 0x46d,
+    Quechua_Bolivia                             = 0x46b,
-    Luxembourgish                               = 0x46e,
+    Quechua_Ecuador                             = 0x86b,
-    Greenlandic                                 = 0x46f,
+    Quechua_Peru                                = 0xc6b,
-    Igbo                                        = 0x470,
+    SesothoSaLeboa                              = 0x46c,
-    Kanuri                                      = 0x471,
+    Bashkir                                     = 0x46d,
-    Oromo                                       = 0x472,
+    Luxembourgish                               = 0x46e,
-    Tigrinya_Ethiopia                           = 0x473,
+    Greenlandic                                 = 0x46f,
-    Tigrinya_Eritrea                            = 0x873,
+    Igbo                                        = 0x470,
-    Guarani                                     = 0x474,
+    Kanuri                                      = 0x471,
-    Hawaiian                                    = 0x475,
+    Oromo                                       = 0x472,
-    Latin                                       = 0x476,
+    Tigrinya_Ethiopia                           = 0x473,
-    Somali                                      = 0x477,
+    Tigrinya_Eritrea                            = 0x873,
-    Yi_PRC                                      = 0x478,
+    Guarani                                     = 0x474,
-    Papiamentu                                  = 0x479,
+    Hawaiian                                    = 0x475,
-    Mapudungun                                  = 0x47a,
+    Latin                                       = 0x476,
-    Mohawk                                      = 0x47c,
+    Somali                                      = 0x477,
-    Breton                                      = 0x47e,
+    Yi_PRC                                      = 0x478,
-    Uyghur_PRC                                  = 0x480,
+    Papiamentu                                  = 0x479,
-    Maori                                       = 0x481,
+    Mapudungun                                  = 0x47a,
-    Occitan                                     = 0x482,
+    Mohawk                                      = 0x47c,
-    Corsican                                    = 0x483,
+    Breton                                      = 0x47e,
-    Alsatian                                    = 0x484,
+    Uyghur_PRC                                  = 0x480,
-    Sakha                                       = 0x485,
+    Maori                                       = 0x481,
-    Kiche                                       = 0x486,
+    Occitan                                     = 0x482,
-    Kinyarwanda                                 = 0x487,
+    Corsican                                    = 0x483,
-    Wolof                                       = 0x488,
+    Alsatian                                    = 0x484,
-    Dari                                        = 0x48c,
+    Sakha                                       = 0x485,
-    ScottishGaelic_UnitedKingdom                = 0x491,
+    Kiche                                       = 0x486,
-    CentralKurdish_Iraq                         = 0x492
+    Kinyarwanda                                 = 0x487,
-};
+    Wolof                                       = 0x488,
-
+    Dari                                        = 0x48c,
-struct DirectoryListingEntry {
+    ScottishGaelic_UnitedKingdom                = 0x491,
-    type::LEB128 nameLength;
+    CentralKurdish_Iraq                         = 0x492
-    char name[nameLength];
+};
-    type::LEB128 contentSection;
+
-    type::LEB128 offset;
+struct DirectoryListingEntry {
-    type::LEB128 length;
+    type::LEB128 nameLength;
-};
+    char name[nameLength];
-
+    type::LEB128 contentSection;
-struct DirectoryIndexEntry {
+    type::LEB128 offset;
-    type::LEB128 nameLength;
+    type::LEB128 length;
-    char name[nameLength];
+};
-    type::LEB128 directoryListingChunk;
+
-};
+struct DirectoryIndexEntry {
-
+    type::LEB128 nameLength;
-struct ListingChunk {
+    char name[nameLength];
-    char magic[4];
+    type::LEB128 directoryListingChunk;
-    
+};
-    if (magic == "PMGL") {
+
-        type::Size<u32> freeSpaceLength;
+struct ListingChunk {
-        u32;
+    char magic[4];
-        u32 prevChunkNumber, nextChunkNumber;
+
-        
+    if (magic == "PMGL") {
-        u16 directoryListingEntryCount @ addressof(this) + parent.directoryChunkSize - 2;
+        type::Size<u32> freeSpaceLength;
-        u16 offsets[(freeSpaceLength - 2) / 2] @ addressof(directoryListingEntryCount) - (freeSpaceLength - 2);
+        u32;
-        
+        u32 prevChunkNumber, nextChunkNumber;
-        DirectoryListingEntry directories[directoryListingEntryCount];
+
-        
+        u16 directoryListingEntryCount @ addressof(this) + parent.directoryChunkSize - 2;
-        $ = addressof(directoryListingEntryCount) + sizeof(directoryListingEntryCount);
+        u16 offsets[(freeSpaceLength - 2) / 2] @ addressof(directoryListingEntryCount) - (freeSpaceLength - 2);
-    } else if (magic == "PMGI") {
+
-        type::Size<u32> freeSpaceLength;
+        DirectoryListingEntry directories[directoryListingEntryCount];
-        
+
-        u16 directoryIndexEntryCount @ addressof(this) + parent.directoryChunkSize - 2;
+        $ = addressof(directoryListingEntryCount) + sizeof(directoryListingEntryCount);
-        u16 offsets[(freeSpaceLength - 2) / 2] @ addressof(directoryIndexEntryCount) - (freeSpaceLength - 2);
+    } else if (magic == "PMGI") {
-        
+        type::Size<u32> freeSpaceLength;
-        DirectoryIndexEntry indexes[directoryIndexEntryCount];
+
-        
+        u16 directoryIndexEntryCount @ addressof(this) + parent.directoryChunkSize - 2;
-        $ = addressof(directoryIndexEntryCount) + sizeof(directoryIndexEntryCount);
+        u16 offsets[(freeSpaceLength - 2) / 2] @ addressof(directoryIndexEntryCount) - (freeSpaceLength - 2);
-    } else {
+
-        std::error("Invalid chunk magic!");
+        DirectoryIndexEntry indexes[directoryIndexEntryCount];
-    }
+
-};
+        $ = addressof(directoryIndexEntryCount) + sizeof(directoryIndexEntryCount);
-
+    } else {
-struct HeaderSection {
+        std::error("Invalid chunk magic!");
-    char magic[4];
+    }
-    
+};
-    if (magic == "\xFE\x01\x00\x00") {
+
-        u32;
+struct HeaderSection {
-        type::Size<u64> fileSize;
+    char magic[4];
-        u32;
+
-        u32;
+    if (magic == "\xFE\x01\x00\x00") {
-    } else if (magic == "ITSP") {
+        u32;
-        u32 version;
+        type::Size<u64> fileSize;
-        type::Size<u32> directoryHeaderLength1;
+        u32;
-        u32;
+        u32;
-        u32 directoryChunkSize;
+    } else if (magic == "ITSP") {
-        u32 quickRefSectionDensity;
+        u32 version;
-        u32 indexTreeDepth;
+        type::Size<u32> directoryHeaderLength1;
-        u32 rootIndexChunkNumber;
+        u32;
-        u32 firstPMGLChunkNumber;
+        u32 directoryChunkSize;
-        u32 lastPMGLChunkNumber;
+        u32 quickRefSectionDensity;
-        u32;
+        u32 indexTreeDepth;
-        u32 directoryChunkCount;
+        u32 rootIndexChunkNumber;
-        WindowsLanguageId languageId;
+        u32 firstPMGLChunkNumber;
-        type::GUID guid;
+        u32 lastPMGLChunkNumber;
-        type::Size<u32> directoryHeaderLength2;
+        u32;
-        u32;
+        u32 directoryChunkCount;
-        u32;
+        WindowsLanguageId languageId;
-        u32;
+        type::GUID guid;
-        
+        type::Size<u32> directoryHeaderLength2;
-        ListingChunk chunk[directoryChunkCount];
+        u32;
-    } else {
+        u32;
-        std::error("Invalid header section magic!");
+        u32;
-    }
+
-};
+        ListingChunk chunk[directoryChunkCount];
-
+    } else {
-struct HeaderSectionTableEntry {
+        std::error("Invalid header section magic!");
-    u64 offset;
+    }
-    type::Size<u64> size;
+};
-    
+
-    HeaderSection headerSection @ offset;
+struct HeaderSectionTableEntry {
-};
+    u64 offset;
-
+    type::Size<u64> size;
-struct NameListEntry {
+
-    type::Size<u16> nameLength;
+    HeaderSection headerSection @ offset;
-    char16 name[nameLength];  
+};
-    padding[2];
+
-};
+struct NameListEntry {
-
+    type::Size<u16> nameLength;
-struct NameListFile {
+    char16 name[nameLength];
-    u16 fileLengthWords;
+    padding[2];
-    u16 entriesInFile;
+};
-    
+
-    NameListEntry nameList[entriesInFile];
+struct NameListFile {
-    
+    u16 fileLengthWords;
-    padding[0x2E];
+    u16 entriesInFile;
-};
+
-
+    NameListEntry nameList[entriesInFile];
-struct SectionData {
+
-    u32 fileLengthWords;
+    padding[0x2E];
-    type::Magic<"LZXC"> magic;
+};
-    u32 version;
+
-    u32 lzxResetInterval;
+struct SectionData {
-    type::Size<u32> windowSize;
+    u32 fileLengthWords;
-    type::Size<u32> cacheSize;
+    type::Magic<"LZXC"> magic;
-    u32;
+    u32 version;
-};
+    u32 lzxResetInterval;
-
+    type::Size<u32> windowSize;
-struct Content {    
+    type::Size<u32> cacheSize;
-    NameListFile nameListFile;
+    u32;
-    SectionData sectionData;
+};
-};
+
-
+struct Content {
-struct CHM {
+    NameListFile nameListFile;
-    type::Magic<"ITSF"> magic;
+    SectionData sectionData;
-    u32 version;
+};
-    type::Size<u32> headerSize;
+
-    u32;
+struct CHM {
-    be u32 timeStamp;
+    type::Magic<"ITSF"> magic;
-    WindowsLanguageId languageId;
+    u32 version;
-    type::GUID guids[2];
+    type::Size<u32> headerSize;
-    
+    u32;
-    HeaderSectionTableEntry headerSectionTable[2];
+    be u32 timeStamp;
-    
+    WindowsLanguageId languageId;
-    Content *dataOffset : u64;
+    type::GUID guids[2];
-};
+
-
+    HeaderSectionTableEntry headerSectionTable[2];
-CHM chm @ 0x00;
+
+    Content *dataOffset : u64;
+};
+
+CHM chm @ 0x00;

patterns/coff.hexpat

@@ -1,7 +1,10 @@
+#pragma author WerWolv
+#pragma description Common Object File Format (COFF) executable
+
 #pragma MIME application/x-coff
 
-#include <type/time.pat>
+import type.time;
-#include <type/size.pat>
+import type.size;
 
 enum Machine : u16 {
     Unknown     = 0x0000,
@@ -113,11 +116,11 @@ struct SymbolTable {
     Type type;
     StorageClass storageClass;
     u8 numberOfAuxSymbols;
-    
+
     countedSymbols += 1 + numberOfAuxSymbols;
-    
+
     AuxSymbol auxSymbols[numberOfAuxSymbols];
-    
+
     if (countedSymbols >= parent.header.numberOfSymbols)
         break;
 };
@@ -161,7 +164,10 @@ bitfield SectionFlags {
 };
 
 fn format_alignment(u8 alignment) {
-    return 1 << alignment;
+    if(alignment > 0) {
+        return 1 << (alignment - 1);
+    }
+    return alignment;
 };
 
 struct Relocations {
@@ -181,7 +187,7 @@ struct Section {
     u16 numberOfRelocations;
     u16 numberOfLineNumbers;
     SectionFlags characteristics;
-    
+
     u8 rawData[sizeOfRawData] @ pointerToRawData [[sealed]];
     Relocations relocations[numberOfRelocations] @ pointerToRelocations;
 };
@@ -199,9 +205,9 @@ struct Header {
 
 struct COFF {
     Header header;
-    
+
     Section sectionTable[header.numberOfSections];
-    
+
     SymbolTable symbolTable[header.numberOfSymbols] @ header.pointerToSymbolTable;
     StringTable stringTable @ addressof(symbolTable) + sizeof(symbolTable);
 };

patterns/commodore_basic.hexpat

@@ -0,0 +1,158 @@
+#pragma description Commodore BASIC
+#pragma author Stephen Hewitt
+
+import std.io;
+import std.mem;
+
+bool in_quotes = false;
+
+le u16 LoadAddress @0 [[color("ff0000")]];
+
+fn formatll(u16 offset) {
+    if (offset&0xff00 == 0)
+        return "No next line";
+    u16 fo = offset-LoadAddress+2;
+    return std::format("Next line: ${:04X} (offset ${:04X})", offset, fo);
+};
+
+enum Token : u8 {
+    END      = 0x80,
+    FOR      = 0x81,
+    NEXT     = 0x82,
+    DATA     = 0x83,
+    INPUT_   = 0x84,
+    INPUT    = 0x85,
+    DIM      = 0x86,
+    READ     = 0x87,
+    LET      = 0x88,
+    GOTO     = 0x89,
+    RUN      = 0x8a,
+    IF       = 0x8b,
+    RESTORE  = 0x8c,
+    GOSUB    = 0x8d,
+    RETURN   = 0x8e,
+    REM      = 0x8f,
+    STOP     = 0x90,
+    ON       = 0x91,
+    WAIT     = 0x92,
+    LOAD     = 0x93,
+    SAVE     = 0x94,
+    VERIFY   = 0x95,
+    DEF      = 0x96,
+    POKE     = 0x97,
+    PRINT_   = 0x98,
+    PRINT    = 0x99,
+    CONT     = 0x9a,
+    LIST     = 0x9b,
+    CLR      = 0x9c,
+    CMD      = 0x9d,
+    SYS      = 0x9e,
+    OPEN     = 0x9f,
+    CLOSE    = 0xa0,
+    GET      = 0xa1,
+    NEW      = 0xa2,
+    TAB_     = 0xa3,
+    TO       = 0xa4,
+    FN       = 0xa5,
+    SPC_     = 0xa6,
+    THEN     = 0xa7,
+    NOT      = 0xa8,
+    STEP     = 0xa9,
+    PLUS_    = 0xaa,
+    MINUS_   = 0xab,
+    TIMES_   = 0xac,
+    DIVIDE_  = 0xad,
+    POW_     = 0xae,
+    AND      = 0xaf,
+    OR       = 0xb0,
+    GT_      = 0xb1,
+    EQ_      = 0xb2,
+    LT_      = 0xb3,
+    SGN      = 0xb4,
+    INT      = 0xb5,
+    ABS      = 0xb6,
+    USR      = 0xb7,
+    FRE      = 0xb7,
+    POS      = 0xb9,
+    SQR      = 0xba,
+    RND      = 0xbb,
+    LOG      = 0xbc,
+    EXP      = 0xbd,
+    COS      = 0xbe,
+    SIN      = 0xbf,
+    TAN      = 0xc0,
+    ATN      = 0xc1,
+    PEEK     = 0xc2,
+    LEN      = 0xc3,
+    STR_     = 0xc4,
+    VAL      = 0xc5,
+    ASC      = 0xc6,
+    CHR_     = 0xc7,
+    LEFT_    = 0xc8,
+    RIGHT_   = 0xc9,
+    MID_     = 0xca,
+    PI_      = 0xff
+} [[format("formate")]];
+
+// Can't seem to put attributes on enum members. Hack around it.
+fn formate(Token t) {
+    match (t) {
+        (Token::INPUT_):  return "INPUT#"; // $84
+        (Token::PRINT_):  return "PRINT#"; // $98
+        (Token::TAB_):    return "TAB(";   // $a3
+        (Token::SPC_):    return "SPC(";   // $a6
+        (Token::PLUS_):   return "+";      // $aa
+        (Token::MINUS_):  return "-";      // $ab
+        (Token::TIMES_):  return "*";      // $ac
+        (Token::DIVIDE_): return "/";      // $ad
+        //(Token::POW_):    return "↑";      // $ae
+        (Token::GT_):     return ">";      // $b1
+        (Token::EQ_):     return "=";      // $b2
+        (Token::LT_):     return "<";      // $b3
+        (Token::STR_):    return "STR$";   // $c4
+        (Token::CHR_):    return "CHR$";   // $c7
+        (Token::LEFT_):   return "LEFT$";  // $c8
+        (Token::RIGHT_):  return "RIGHT$"; // $c9
+        (Token::MID_):    return "MID$";   // $ca
+        //(Token::PI_):     return "π";      // $ff
+    }
+
+    return t;
+};
+
+fn NotZero() {
+    u8 b = std::mem::read_unsigned($, 1);
+    return b!=0;
+};
+
+fn IsToken() {
+     u8 b = std::mem::read_unsigned($, 1);
+     return b&0x80!=0;
+};
+
+fn IsPETSCII() {
+    u8 b = std::mem::read_unsigned($, 1);
+    if (b == '"')
+        in_quotes = !in_quotes;
+    return (b!=0) && (in_quotes || (b&0x80)==0);
+};
+
+struct LineSegment
+{
+    Token tokens[while(IsToken())] [[color("a040a0")]]; 
+    char petscii[while(IsPETSCII())] [[color("a0a0a0")]]; 
+};
+
+struct Line
+{
+    in_quotes = false;
+
+    u16 next [[color("8080ff"), format("formatll")]];
+    if (next&0xff00 == 0)
+        break;
+    le u16 line_number [[color("00FF00")]];
+    LineSegment contents[while(NotZero())];
+    u8 eol [[color("00ffff")]];
+};
+
+Line Lines[while(!std::mem::eof())] @ 2;

patterns/cpio.hexpat

@@ -1,66 +1,69 @@
-#include <type/base.pat>
+#pragma author WerWolv
-
+#pragma description Old Binary CPIO
-#include <std/time.pat>
+
-#include <std/core.pat>
+import type.base;
-#include <std/sys.pat>
+
-#include <std/mem.pat>
+import std.time;
-
+import std.core;
-#pragma MIME application/x-cpio
+import std.sys;
-
+import std.mem;
-namespace old_binary {
+
-
+#pragma MIME application/x-cpio
-    using Time = u32 [[format("old_binary::format_time")]];
+
-
+namespace old_binary {
-    fn swap_32bit(u32 value) {
+
-        return ((value >> 16) & 0xFFFF) | ((value & 0xFFFF) << 16);
+    using Time = u32 [[format("old_binary::format_time")]];
-    };
+
-
+    fn swap_32bit(u32 value) {
-    fn format_time(u32 value) {
+        return ((value >> 16) & 0xFFFF) | ((value & 0xFFFF) << 16);
-        return std::time::format(std::time::to_utc(swap_32bit(value)));
+    };
-    };
+
-
+    fn format_time(u32 value) {
-    using SwappedU32 = u32 [[transform("old_binary::swap_32bit"), format("old_binary::swap_32bit")]];
+        return std::time::format(std::time::to_utc(old_binary::swap_32bit(value)));
-
+    };
-    bitfield Mode {
+
-        x           : 3;
+    using SwappedU32 = u32 [[transform("old_binary::swap_32bit"), format("old_binary::swap_32bit")]];
-        w           : 3;
+
-        r           : 3;
+    bitfield Mode {
-        sticky      : 1;
+        x           : 3;
-        sgid        : 1;
+        w           : 3;
-        suid        : 1;
+        r           : 3;
-        file_type   : 4;
+        sticky      : 1;
-    };
+        sgid        : 1;
-
+        suid        : 1;
-    struct CpioHeader {
+        file_type   : 4;
-        type::Oct<u16> magic;
+    };
-        if (magic == be u16(0o070707))
+
-            std::core::set_endian(std::mem::Endian::Big);
+    struct CpioHeader {
-        else if (magic == le u16(0o070707))
+        type::Oct<u16> magic;
-            std::core::set_endian(std::mem::Endian::Little);
+        if (magic == be u16(0o070707))
-        else
+            std::core::set_endian(std::mem::Endian::Big);
-            std::error("Invalid CPIO Magic!");
+        else if (magic == le u16(0o070707))
-        
+            std::core::set_endian(std::mem::Endian::Little);
-        u16 dev;
+        else
-        u16 ino;
+            std::error("Invalid CPIO Magic!");
-        Mode mode;
+
-        u16 uid;
+        u16 dev;
-        u16 gid;
+        u16 ino;
-        u16 nlink;
+        Mode mode;
-        u16 rdev;
+        u16 uid;
-        Time mtime;
+        u16 gid;
-        u16 namesize;
+        u16 nlink;
-        SwappedU32 filesize;
+        u16 rdev;
-    };
+        Time mtime;
-
+        u16 namesize;
-    struct Cpio {
+        SwappedU32 filesize;
-        CpioHeader header;
+    };
-        char pathname[header.namesize % 2 == 0 ? header.namesize : header.namesize + 1];
+
-        u8 data[header.filesize % 2 == 0 ? header.filesize : header.filesize + 1];
+    struct Cpio {
-        
+        CpioHeader header;
-        if (pathname == "TRAILER!!!\x00\x00")
+        char pathname[header.namesize % 2 == 0 ? header.namesize : header.namesize + 1];
-            break;
+        u8 data[header.filesize % 2 == 0 ? header.filesize : header.filesize + 1];
-    };
+
-
+        if (pathname == "TRAILER!!!\x00\x00")
-}
+            break;
-
+    };
-old_binary::Cpio cpio[while(true)] @ 0x00;
+
+}
+
+old_binary::Cpio cpio[while(true)] @ 0x00;

patterns/credhist.hexpat

@@ -0,0 +1,99 @@
+#pragma description "CREDHIST"
+
+/*
+        FilePath: C:\Users\<USER>\AppData\Roaming\Microsoft\Protect\
+        The files/folders are hidden.
+
+        To unhide it
+        1. Open Command Prompt (cmd.exe).
+        2. Run the following command:
+            => attrib -h -s
+
+*/
+
+import type.guid;
+import std.mem;
+
+// https://learn.microsoft.com/en-us/windows/win32/seccrypto/alg-id
+enum ALG_ID : u32 {
+    CALG_DH_EPHEM = 0x0000aa02,        // Diffie-Hellman ephemeral key exchange algorithm.
+    CALG_DH_SF = 0x0000aa01,           // Diffie-Hellman store and forward key exchange algorithm.
+    CALG_DSS_SIGN = 0x00002200,        // DSA public key signature algorithm.
+    CALG_ECDH = 0x0000aa05,            // Elliptic curve Diffie-Hellman key exchange algorithm.
+    CALG_ECDH_EPHEM = 0x0000ae06,      // Ephemeral elliptic curve Diffie-Hellman key exchange algorithm.
+    CALG_ECDSA = 0x00002203,           // Elliptic curve digital signature algorithm.
+    CALG_ECMQV = 0x0000a001,           // Elliptic curve Menezes, Qu, and Vanstone (MQV) key exchange algorithm.
+    CALG_HASH_REPLACE_OWF = 0x0000800b, // One way function hashing algorithm.
+    CALG_HUGHES_MD5 = 0x0000a003,      // Hughes MD5 hashing algorithm.
+    CALG_HMAC = 0x00008009,            // HMAC keyed hash algorithm.
+    CALG_KEA_KEYX = 0x0000aa04,        // KEA key exchange algorithm (FORTEZZA).
+    CALG_MAC = 0x00008005,             // MAC keyed hash algorithm.
+    CALG_MD2 = 0x00008001,             // MD2 hashing algorithm.
+    CALG_MD4 = 0x00008002,             // MD4 hashing algorithm.
+    CALG_MD5 = 0x00008003,             // MD5 hashing algorithm.
+    CALG_NO_SIGN = 0x00002000,         // No signature algorithm.
+    CALG_OID_INFO_CNG_ONLY = 0xffffffff, // Algorithm is only implemented in CNG.
+    CALG_OID_INFO_PARAMETERS = 0xfffffffe, // Algorithm is defined in the encoded parameters.
+    CALG_PCT1_MASTER = 0x00004c04,     // Used by the Schannel.dll operations system.
+    CALG_RC2 = 0x00006602,             // RC2 block encryption algorithm.
+    CALG_RC4 = 0x00006801,             // RC4 stream encryption algorithm.
+    CALG_RC5 = 0x0000660d,             // RC5 block encryption algorithm.
+    CALG_RSA_KEYX = 0x0000a400,        // RSA public key exchange algorithm.
+    CALG_RSA_SIGN = 0x00002400,        // RSA public key signature algorithm.
+    CALG_SCHANNEL_ENC_KEY = 0x00004c07, // Used by the Schannel.dll operations system.
+    CALG_SCHANNEL_MAC_KEY = 0x00004c03, // Used by the Schannel.dll operations system.
+    CALG_SCHANNEL_MASTER_HASH = 0x00004c02, // Used by the Schannel.dll operations system.
+    CALG_SEAL = 0x00006802,            // SEAL encryption algorithm.
+    CALG_SHA = 0x00008004,             // SHA hashing algorithm.
+    CALG_SHA1 = 0x00008004,            // Same as CALG_SHA.
+    CALG_SHA_256 = 0x0000800c,         // 256-bit SHA hashing algorithm.
+    CALG_SHA_384 = 0x0000800d,         // 384-bit SHA hashing algorithm.
+    CALG_SHA_512 = 0x0000800e,         // 512-bit SHA hashing algorithm.
+    CALG_SKIPJACK = 0x0000660a,        // Skipjack block encryption algorithm (FORTEZZA).
+    CALG_SSL2_MASTER = 0x00004c05,     // Used by the Schannel.dll operations system.
+    CALG_SSL3_MASTER = 0x00004c01,     // Used by the Schannel.dll operations system.
+    CALG_SSL3_SHAMD5 = 0x00008008,     // Used by the Schannel.dll operations system.
+    CALG_TEK = 0x0000660b,             // TEK (FORTEZZA).
+    CALG_TLS1_MASTER = 0x00004c06,     // Used by the Schannel.dll operations system.
+    CALG_TLS1PRF = 0x0000800a          // Used by the Schannel.dll operations system.
+};
+
+// https://devblogs.microsoft.com/oldnewthing/20040315-00/?p=40253
+struct SID {
+    u8 revisionlvl[[name("RevisionLevel"), comment("SID_REVISION")]];
+    u8 dashes[[name("NoOfDashes"), comment("number of dashes minus two")]]; // dashes = actualdashes - 0x2
+    char ntauth[0x6][[name("NtAuthority"), comment("SECURITY_NT_AUTHORITY")]];
+    u32  subatuh1[[name("SubAuthority1"), comment("SECURITY_NT_NON_UNIQUE")]];
+    u32  subatuh2[[name("SubAuthority2"), comment("these identify the machine that issued the SID")]];
+    u32  subatuh3[[name("SubAuthority3"), comment("these identify the machine that issued the SID")]];
+    u32  subatuh4[[name("SubAuthority4"), comment("these identify the machine that issued the SID")]];
+    u32  rid[[name("RID"), comment("unique user id on the machine")]];
+};  
+
+
+struct CREDHIST_HEADER{
+    u32 version[[name("Version")]];
+    type::GUID guid[[name("GUID")]];
+    u32 nextlen[[name("NextCredSize")]];
+};
+
+struct CREDHIST {
+    CREDHIST_HEADER credheader[[name("CredHistHeader")]];
+    if (std::mem::eof()){
+        break;
+    }
+    u32 flgas [[name("Flags")]];
+    ALG_ID alghashid[[name("AlgorithmHashId")]];
+    u32 rounds [[name("Rounds")]];
+    u32 sidlen [[name("SIDLen")]];
+    ALG_ID algcryptid[[name("AlgorithmCryptId")]];
+    u32 sha1len[[name("SHA1Len")]];
+    u32 md4len[[name("ntlmlen")]];
+    char salt[0x10][[name("Salt")]];
+    SID sid[[name("SID")]];
+    char sha1hash[sha1len][[name("SHA1Hash")]];
+    char md4hash[md4len][[name("NTLMHash")]];
+    u64 unk1[[name("Unknown")]];
+};
+
+CREDHIST credhist [while(!std::mem::eof())] @ 0x0[[name("CredHist")]];

patterns/dds.hexpat

@@ -1,4 +1,7 @@
+#pragma description DirectDraw Surface
+
 #pragma MIME image/vnd-ms.dds
+#pragma MIME image/x-dds
 #pragma endian little
 
 enum DXGI_FORMAT : u32 {
@@ -165,16 +168,26 @@ bitfield Caps2Flags {
 };
 
 bitfield PixelFormatFlags {
-  alphaPixels : 1;
+  alphaPixels 	    : 1;  // DDPF_ALPHAPIXELS
-  alpha       : 1;
+  alpha       	    : 1;  // DDPF_ALPHA
-  fourCC      : 1;
+  fourCC      	    : 1;  // DDPF_FOURCC
-  padding     : 3;
+  paletteIndexed4   : 1;  // DDPF_PALETTEINDEXED4
-  rgb         : 1; // 0x40
+  paletteIndexedTo8 : 1;  // DDPF_PALETTEINDEXEDTO8
-  padding     : 2;
+  paletteIndexed8   : 1;  // DDPF_PALETTEINDEXED8
-  yuv         : 1; // 0x200
+  rgb               : 1;  // DDPF_RGB
-  padding     : 3;
+  compressed        : 1;  // DDPF_COMPRESSED
-  luminance   : 1; // 0x20000
+  rgbToYuv          : 1;  // DDPF_RGBTOYUV
-  padding     : 17;
+  yuv               : 1;  // DDPF_YUV
+  zBuffer           : 1;  // DDPF_ZBUFFER
+  paletteIndexed1   : 1;  // DDPF_PALETTEINDEXED1
+  paletteIndexed2   : 1;  // DDPF_PALETTEINDEXED2
+  zPixels           : 1;  // DDPF_ZPIXELS
+  stencilBuffer     : 1;  // DDPF_STENCILBUFFER
+  alphaResult       : 1;  // DDPF_ALPHARESULT
+  luminance         : 1;  // DDPF_LUMINANCE
+  bumpLuminance     : 1;  // DDPF_BUMPLUMINANCE
+  bumpDudv          : 1;  // DDPF_BUMPDUDV
+  padding           : 13; // Padding bits to complete 32-bit structure
 };
 
 enum DX10ResourceDimension : u32 {
@@ -190,7 +203,7 @@ enum DX10AlphaMode : u32 {
   Straight,
   PreMultiplied,
   Opaque,
-  Custom,	
+  Custom,
 };
 
 bitfield DX10MiscFlags {

patterns/dex.hexpat

@@ -1,4 +1,7 @@
-#include <type/leb128.pat>
+#pragma description Dalvik EXecutable
+#pragma magic [ 64 65 78 0A ?? ?? ?? 00 ]
+
+import type.leb128;
 
 struct header_item {
     u8 magic[8];
@@ -97,7 +100,7 @@ enum access_flag : type::uLEB128{
     static = 0x8,
     final = 0x10,
     synchronized = 0x20,
-    volatile = 0x40    
+    volatile = 0x40
 };
 
 struct encoded_field {
@@ -132,7 +135,7 @@ struct class_def_item {
     u32 class_data_off;
     //class_data_item *class_data_off:u32;
     u32 static_values_off;
-    char class_name[] @ addressof(parent.type_ids[class_idx].type_name);    
+    char class_name[] @ addressof(parent.type_ids[class_idx].type_name);
 }[[name(class_name)]];
 
 struct type_item {

patterns/dmc3_hd_mod.hexpat

@@ -0,0 +1,165 @@
+#pragma description Devil May Cry 3 HD .mod 3D model file
+#pragma MIME 3d-model/capcom.dmc3-hd-mod
+
+// author = haru233, many thanks to AxCut
+// ImHex Hex Pattern File for Capcom's Devil May Cry 3 HD .mod files
+
+
+import std.core;
+
+
+struct ModelHeader {
+    char ID[4];
+    float Version;
+    padding[8];
+    u8 objectCount;
+    u8 boneCount;
+    u8 numberTextures;
+    u8;
+    u32;
+    u64;
+    u64 skeletonOffset;
+    padding[24];
+};
+
+struct ObjectInfo {
+    u8 meshCount;
+    u8;
+    u16 numberVertices;
+    padding[4];
+    u64 meshOffset;
+    u32 flags;
+    padding[28];
+    float X, Y, Z;           
+    float radius;
+};
+
+struct Positions {
+    float positions[3];
+};
+
+
+struct Normals {
+    float normal[3];
+};
+
+
+struct UVs {
+    s16 uv[2];
+};
+
+struct BoneIndices {
+    u8 boneindex[4];
+};
+
+struct Weights {
+    u16 weight[1];
+};
+
+struct MeshSCM {
+    u16 numberVertices;
+    u16 textureIndex;
+    padding[12];
+    u64 VerticesPositionsOffset;
+    u64 NormalsPositionsOffset;
+    u64 UVsPositionsOffset;
+
+    padding[16];
+    u64 unknownOffset;
+
+    u64;
+    padding[8];
+    
+    Positions positions[numberVertices] @VerticesPositionsOffset;
+    Normals normals[numberVertices] @NormalsPositionsOffset;
+    UVs uvs[numberVertices] @UVsPositionsOffset;
+    
+    
+};
+
+struct Mesh {
+    u16 numberVertices;
+    u16 textureIndex;
+    padding[12];
+    u64 VerticesPositionsOffset;
+    u64 NormalsPositionsOffset;
+    u64 UVsPositionsOffset;
+
+    u64 BoneIndicesOffset;
+    u64 WeightsOffset;
+    padding[8];
+
+    u64;
+    padding[8];
+    
+    Positions positions[numberVertices] @VerticesPositionsOffset;
+    Normals normals[numberVertices] @NormalsPositionsOffset;
+    UVs uvs[numberVertices] @UVsPositionsOffset;
+    
+    BoneIndices b_index[numberVertices] @BoneIndicesOffset;
+    Weights weights[numberVertices] @WeightsOffset;
+    
+   
+};
+
+
+struct Hierarchy {
+    u8 hierarchy;
+};
+
+struct HierarchyOrder {
+    u8 hierarchyorder;
+};
+
+struct Unknown {
+    u8;
+};
+
+struct Transform {
+    float x;
+    float y;
+    float z;
+    float length; // sqrt(x*x + y*y + z*z)
+    padding[16];
+};
+
+struct Skeleton{
+    u32 hierarchyOffset;
+    u32 hierarchyOrderOffset;
+    u32 unknownOffset;
+    u32 transformsOffset;
+};         
+
+
+    
+
+
+ModelHeader modelheader @ 0x00;
+ObjectInfo objects_info[modelheader.objectCount] @ 0x40;
+
+u32 objectOffset;
+
+struct Object {
+   u64 i = std::core::array_index();
+   if (modelheader.ID == "SCM ") {
+        objectOffset = objects_info[0].meshOffset;
+        MeshSCM meshscm[objects_info[i].meshCount] @ objects_info[i].meshOffset;
+        
+        
+    } else {
+        objectOffset = objects_info[0].meshOffset;
+        Mesh mesh[objects_info[i].meshCount] @ objects_info[i].meshOffset;
+    }
+};
+
+Object objects[modelheader.objectCount] @objectOffset;
+
+Skeleton skeleton @modelheader.skeletonOffset;
+
+Hierarchy hierarchy[modelheader.boneCount] @(modelheader.skeletonOffset + skeleton.hierarchyOffset);
+
+HierarchyOrder hierarchyorder[modelheader.boneCount] @(modelheader.skeletonOffset + skeleton.hierarchyOrderOffset);
+
+Unknown unknown[modelheader.boneCount] @(modelheader.skeletonOffset + skeleton.unknownOffset);
+
+Transform transform[modelheader.boneCount] @(modelheader.skeletonOffset + skeleton.transformsOffset);

patterns/dmg.hexpat

@@ -1,49 +1,52 @@
+#pragma description Apple Disk Image Trailer (DMG)
+#pragma magic [ 6B 6F 6C 79 ] @ -512
+
 #pragma endian big
 
-#include <type/magic.pat>
+import type.magic;
-#include <type/size.pat>
+import type.size;
-#include <type/guid.pat>
+import type.guid;
-#include <std/mem.pat>
+import std.mem;
 
 // Parse DMG Structure per http://newosxbook.com/DMG.html
 //
 // UDIFResourceFile starts at size(file) - 512
 struct UDIFResourceFile {
-    type::Magic<"koly"> Signature;  // Magic ('koly')
+    type::Magic<"koly"> Signature;      // Magic ('koly')
-    u32 Version;                    // Current version is 4
+    u32 Version;                        // Current version is 4
-    type::Size<u32> HeaderSize;     // sizeof(this), always 512
+    type::Size<u32> HeaderSize;         // sizeof(this), always 512
     u32 Flags;
-    u64 RunningDataForkOffset;      // 
+    u64 RunningDataForkOffset;          //
-    u64 DataForkOffset;             // Data fork offset (usually 0, beginning of file)
+    u64 DataForkOffset;                 // Data fork offset (usually 0, beginning of file)
-    type::Size<u64> DataForkLength; // Size of data fork (usually up to the XMLOffset, below)
+    type::Size<u64> DataForkLength;     // Size of data fork (usually up to the XMLOffset, below)
-    u64 RsrcForkOffset;             // Resource fork offset, if any
+    u64 RsrcForkOffset;                 // Resource fork offset, if any
-    type::Size<u64> RsrcForkLength; // Resource fork length, if any
+    type::Size<u64> RsrcForkLength;     // Resource fork length, if any
-    u32 SegmentNumber;              // Usually 1, may be 0
+    u32 SegmentNumber;                  // Usually 1, may be 0
-    u32 SegmentCount;               // Usually 1, may be 0
+    u32 SegmentCount;                   // Usually 1, may be 0
-    type::GUID SegmentID;           // 128-bit GUID identifier of segment (if SegmentNumber !=0)
-    
 
-    u32 DataChecksumType;               // Data fork 
+    type::GUID SegmentID;               // 128-bit GUID identifier of segment (if SegmentNumber !=0)
+
+    u32 DataChecksumType;               // Data fork
     type::Size<u32> DataChecksumSize;   // Checksum Information
-    u32 DataChecksum[DataChecksumSize]; // Up to 128-bytes (32 x 4) of checksum
+    u32 DataChecksum[32];               // Up to 128-bytes (32 x 4) of checksum
 
-    u64 XMLOffset;              // Offset of property list in DMG, from beginning
+    u64 XMLOffset;                      // Offset of property list in DMG, from beginning
-    type::Size<u64> XMLLength;  // Length of property list
+    type::Size<u64> XMLLength;          // Length of property list
-    u8  Reserved1[120];         // 120 reserved bytes - zeroed
+    u8  Reserved1[120];                 // 120 reserved bytes - zeroed
 
-    u32 ChecksumType;               // Master
+    u32 ChecksumType;                   // Master
-    type::Size<u32> ChecksumSize;   // Checksum information
+    type::Size<u32> ChecksumSize;       // Checksum information
-    u32 Checksum[ChecksumSize];     // Up to 128-bytes (32 x 4) of checksum
+    u32 Checksum[32];                   // Up to 128-bytes (32 x 4) of checksum
 
-    u32 ImageVariant;          // Commonly 1
+    u32 ImageVariant;                   // Commonly 1
-    u64 SectorCount;           // Size of DMG when expanded, in sectors
+    u64 SectorCount;                    // Size of DMG when expanded, in sectors
 
-    u32 reserved2;             // 0
+    u32 reserved2;                      // 0
-    u32 reserved3;             // 0 
+    u32 reserved3;                      // 0
-    u32 reserved4;             // 0
+    u32 reserved4;                      // 0
 };
 
 
 UDIFResourceFile trailer @ std::mem::size() - 512;
 
-char metadata_plist[trailer.XMLLength] @ trailer.XMLOffset;
+char metadata_plist[trailer.XMLLength] @ trailer.XMLOffset;