include/std: std::ptr::relative_to_base_section not working anymore (#349)

Fixes #348 

In issue #348 it is stated that the pattern fails to find the variable baseAddress in the parent of the parent of the attribute function. One parent is required to access the variables on the pattern that is using the attribute.

That pattern is used in the pattern that contains baseAddress as a pointer to an array of the children pattern and that seems to require an extra parent level to be added in order to access baseAddress without errors. The fix was tested on an xbe file extracted from an xbox cd rom and while it failed without the fix as stated in issue 348 with the fix it ran to completion without issues.

.gitattributes

@@ -1,10 +1,4 @@
 *.pat               linguist-language=Rust
 *.hexpat            linguist-language=Rust
-constants/*         text eol=lf
-encodings/*         text eol=lf
-includes/*          text eol=lf
-magic/*             text eol=lf
-patterns/*          text eol=lf
-structs/*           text eol=lf
-tips/*              text eol=lf
-yara/*              text eol=lf
+
+tests/patterns/test_data/**  binary

.github/PULL_REQUEST_TEMPLATE/pattern_template.md

@@ -0,0 +1,12 @@
+# Pattern
+
+[Information about your pattern]
+
+## 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

.github/workflows/dispatch.yml

@@ -0,0 +1,56 @@
+name: "Dispatch"
+
+on:
+  push:
+    branches: [ '*' ]
+  pull_request:
+    branches: [ '*' ]
+  repository_dispatch:
+    types: [run_tests]
+  workflow_dispatch:
+    inputs:
+      generate_docs:
+        description: "Regenerate docs"
+        required: false
+        type: boolean
+
+jobs:
+  tests:
+    name: 🎯 Dispatch changes
+    runs-on: ubuntu-24.04
+    env:
+      DISPATCH_TOKEN: ${{ secrets.DISPATCH_TOKEN }}
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    steps:
+    - name: 🧰 Checkout
+      uses: actions/checkout@v4
+      with:
+        submodules: recursive
+
+    - name: 📄 Check changed include files
+      id: changed-includes
+      uses: tj-actions/changed-files@v45
+      with:
+        files: includes/**/*.pat
+
+    - name: ✉️ Run Documentation generator
+      if: ${{ env.DISPATCH_TOKEN != '' && (steps.changed-includes.outputs.any_changed == 'true' || inputs.generate_docs || github.event_name == 'repository_dispatch' ) }}
+      uses: mvasigh/dispatch-action@main
+      with:
+        token: ${{ secrets.DISPATCH_TOKEN }}
+        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

@@ -5,11 +5,13 @@ on:
     branches: [ '*' ]
   pull_request:
     branches: [ '*' ]
+  repository_dispatch:
+    types: [run_tests]
 
 jobs:
   tests:
     name: 🧪 Unit Tests
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-24.04
     permissions:
       actions: read
       contents: read
@@ -17,9 +19,8 @@ jobs:
 
     steps:
     - name: 🧰 Checkout
-      uses: actions/checkout@v2
+      uses: actions/checkout@v4
       with:
-        fetch-depth: 0
         submodules: recursive
 
     - name: ⬇️ Install dependencies
@@ -27,39 +28,54 @@ jobs:
         sudo apt update
         sudo apt install -y       \
             build-essential       \
-            gcc-11                \
-            g++-11                \
+            ccache                \
+            gcc-14                \
+            g++-14                \
             lld                   \
             ${PKGCONF:-}          \
             cmake                 \
-            make                  \
+            ninja-build           \
             python3               \
-            python3-pip
-        
+            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-11 CXX=g++-11 cmake              \
-          -DCMAKE_C_FLAGS="-fuse-ld=lld"        \
-          -DCMAKE_CXX_FLAGS="-fuse-ld=lld"      \
-          -DLIBPL_ENABLE_TESTS=OFF              \
+        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
-        ctest
+        cd build
+        ctest --output-on-failure -j 4
+
     - 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,4 +1,12 @@
 
-tests/cmake-build-debug/
+tests/cmake*/
+tests/build*/
+build/
 
+.vscode/
+.devcontainer/
+.cache/
 .idea/
+.DS_Store
+
+compile_commands.json

.gitmodules

@@ -2,7 +2,9 @@
 	path = yara/official_rules
 	url = https://github.com/Yara-Rules/rules
 	branch = master
-[submodule "tests/lib/pl"]
-	path = tests/lib/pl
-	url = https://github.com/WerWolv/PatternLanguage
-	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

@@ -0,0 +1,12 @@
+# Contributing
+
+Contributing to the Database is very simple. Fork this repository, add your new files (or changes to existing files) to the right folders and create a PR.
+When adding new files, please make sure to also add a link to them to the Table of Contents in the README.md file. That way the files can be discovered by others more easily.
+
+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 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,21 @@
-# ImHex-Patterns
+# ImHex Database
 
-Hex patterns, include patterns and magic files for the use with the ImHex Hex Editor
+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
+- [Encodings](/encodings) - Custom encodings in the .tbl format
+- [Data Processor Nodes](/nodes) - Custom nodes made for ImHex's Data Processor
+- [Themes](/themes) - Custom themes for ImHex
+- [Constants](/constants) - Constants definition files
+- [Scripts](/scripts) - Various scripts to generate code or automate some tasks
+- [Yara](/yara) - Custom Yara rules
+
+## Submissions
+
+Most files in this repository have been submitted by the community. Please feel free to open a PR on your own and add files to it!
+Everything will immediately show up in ImHex's Content Store and gets bundled with the next release of ImHex.
 
 ## Table of Contents
 
@@ -8,83 +23,252 @@ Hex patterns, include patterns and magic files for the use with the ImHex Hex Ed
 
 | Name | MIME | Path | Description |
 |------|------|------|-------------|
-| BMP  | `image/bmp` | `patterns/bmp.hexpat` | OS2/Windows Bitmap files |
-| ELF  | `application/x-executable`, `application/x-sharedlib` | `patterns/elf.hexpat` | ELF header in elf binaries |
-| PE   | `application/x-dosexec` | `patterns/pe.hexpat` | PE header, COFF header, Standard COFF fields and Windows Specific fields |
-| Intel HEX  | | `patterns/intel_hex.hexpat` | [Intel hexadecimal object file format definition]("https://en.wikipedia.org/wiki/Intel_HEX") |
-| MIDI | `audio/midi` | `patterns/midi.hexpat` | MIDI header, event fields provided |
-| WAV  | `audio/wav`  | `patterns/wav.hexpat`  | RIFF header, WAVE header, PCM header |
-| ZIP  | `application/zip` | `patterns/zip.hexpat` | End of Central Directory Header, Central Directory File Headers |
-| PCAP | `application/vnd.tcpdump.pcap` | `patterns/pcap.hexpat` | pcap header and packets | 
-| SPIRV | | `patterns/spirv.hexpat` | SPIR-V header and instructions | 
-| AFE2 | | `patterns/afe2.hexpat` | Nintendo Switch Atmosphère CFW Fatal Error log | 
-| AR | `application/x-archive` | `patterns/ar.hexpat` | Static library archive files | 
-| NACP | | `patterns/nacp.hexpat` | Nintendo Switch NACP files | 
-| NRO | | `patterns/nro.hexpat` | Nintendo Switch NRO files | 
-| PRODINFO | | `patterns/prodinfo.hexpat` | Nintendo Switch PRODINFO | 
-| Java Class | `application/x-java-applet` | `patterns/java_class.hexpat` | Java Class files | 
-| ARM VTOR | | `patterns/arm_cm_vtor.hexpat` | ARM Cortex M Vector Table Layout | 
-| ICO | | `patterns/ico.hexpat` | Icon (.ico) or Cursor (.cur) files | 
-| PNG  | `image/png` | `patterns/png.hexpat` | PNG image files | 
-| DDS | `image/vnd-ms.dds` | `patterns/dds.hexpat` | DirectDraw Surface |
-| TGA | `image/tga` | `patterns/tga.hexpat` | Truevision TGA/TARGA image |
-| ISO | | `patterns/iso.hexpat` | ISO 9660 file system |
-| VDF | | `patterns/vdf.hexpat` | Binary Value Data Format (.vdf) files | 
-| IP | | `patterns/ip.hexpat` | Ethernet II Frames (IP Packets) | 
-| UF2 | | `patterns/uf2.hexpat` | [USB Flashing Format](https://github.com/microsoft/uf2) | 
+| 3DS | | [`patterns/3ds.hexpat`](patterns/3ds.hexpat) | Autodesk 3DS Max Model file |
+| 7Z | | [`patterns/7z.hexpat`](patterns/7z.hexpat) | 7z File Format |
+| ADTS | `audio/x-hx-aac-adts` | [`patterns/adts.hexpat`](patterns/adts.hexpat) | ADTS/AAC audio 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 |
+| 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 |
+| 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) | GoldSrc engine maps format (used in Half-Life 1) |
+| 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 | `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 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) |
+| DMP | | [`patterns/dmp64.hexpat`](patterns/dmp64.hexpat) | Windows Kernel Dump(DMP64) |
+| 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 | `application/x-ms-evtx` | [`patterns/evtx.hexpat`](patterns/evtx.hexpat) | MS Windows Vista Event Log |
+| EXT4 | | [`patterns/ext4.hexpat`](patterns/ext4.hexpat) | Ext4 filesystem |
+| 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 |
+| FBX | | [`patterns/fbx.hexpat`](patterns/fbx.hexpat) | Kaydara FBX Binary |
+| FDT | | [`patterns/fdt.hexpat`](patterns/fdt.hexpat) | Flat Linux Device Tree blob |
+| FFX | | [`patterns/ffx/*`](https://gitlab.com/EvelynTSMG/imhex-ffx-pats) | Various Final Fantasy X files |
+| File System | `application/x-ima` | [`patterns/fs.hexpat`](patterns/fs.hexpat) | Drive File System |
+| FLAC | `audio/flac` | [`patterns/flac.hexpat`](patterns/flac.hexpat) | Free Lossless Audio Codec, FLAC Audio Format |
+| 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 |
+| 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 |
+| 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 |
+| 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) |
+| IPS | | [`patterns/ips.hexpat`](patterns/ips.hexpat) | IPS (International Patching System) 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 |
+| mp4 | `video/mp4` | [`patterns/mp4.hexpat`](patterns/mp4.hexpat) | MPEG-4 Part 14 digital multimedia container format |
+| 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 | `application/x-ms-ne-executable` | [`patterns/ne.hexpat`](patterns/ne.hexpat) | NE header and Standard NE fields |
+| nes | | [`patterns/nes.hexpat`](patterns/nes.hexpat) | .nes file format |
+| NotepadCache | | [`patterns/notepad-cache.hexpat`](patterns/notepad-cache.hexpat) | Windows Notepad Cache |
+| 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 |
+| OGG | `audio/ogg` | [`patterns/ogg.hexpat`](patterns/ogg.hexpat) | OGG Audio 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 |
+| 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` `application/x-msdownload` | [`patterns/pe.hexpat`](patterns/pe.hexpat) | PE header, COFF header, Standard COFF fields and Windows Specific fields |
+| PP | | [`patterns/selinuxpp.hexpat`](patterns/selinuxpp.pat) | SE Linux package |
+| PFS0 | | [`patterns/pfs0.hexpat`](patterns/pfs0.hexpat) | Nintendo Switch PFS0 archive (NSP files) |
+| PIF | `image/pif` | [`patterns/pif.hexpat`](patterns/pif.hexpat) | PIF Image Format |
+| PKM | | [`patterns/pkm.hexpat`](patterns/pkm.hexpat) | PKM texture format |
+| PNG  | `image/png` | [`patterns/png.hexpat`](patterns/png.hexpat) | PNG image files |
+| 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 |
+| quantized-mesh | | [`patterns/quantized-mesh.hexpat`](patterns/quantized-mesh.hexpat) | Cesium quantized-mesh terrain |
+| 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 |
+| ReFS | | [`patterns/refs.hexpat`](patterns/refs.hexpat) | Microsoft Resilient File System |
+| RGBDS | | [`patterns/rgbds.hexpat`](patterns/rgbds.hexpat) | [RGBDS](https://rgbds.gbdev.io) object 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 |
+| shx | | [`patterns/shx.hexpat`](patterns/shx.hexpat) | ESRI index file |
+| sup | | [`patterns/sup.hexpat`](patterns/sup.hexpat) | PGS Subtitle |
+| SPIRV | | [`patterns/spirv.hexpat`](patterns/spirv.hexpat) | SPIR-V header and instructions |
+| 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 |
+| TAR | `application/x-tar` | [`patterns/tar.hexpat`](patterns/tar.hexpat) | Tar file format |
+| TES | | [`patterns/wintec_tes.hexpat`](patterns/wintec_tes.hexpat) | Wintec TES GPS log |
+| 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 |
+| UEFI | | [`patterns/uefi.hexpat`](patterns/uefi.hexpat)` | UEFI structs for parsing efivars |
+| UEFI Boot Entry | | [`patterns/uefi_boot_entry.hexpat`](patterns/uefi_boot_entry.hexpat) | UEFI Boot Entry (Load option) |
+| UF2 | | [`patterns/uf2.hexpat`](patterns/uf2.hexpat) | [USB Flashing Format](https://github.com/microsoft/uf2) |
+| 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 |
+| 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 cartridge ROM |
+| 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 |
+| 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 |
 
 ### Scripts
 
 | Name | Path | Description |
 |------|------|-------------|
-| svd2pat | `scripts/svd2pat.py` | Converts a ARM .svd register MMIO definition file into a pattern |
+| svd2pat | [`scripts/svd2pat.py`](scripts/svd2pat.py) | Converts a ARM .svd register MMIO definition file into a pattern |
+| csv2tbl | [`scripts/csv2tbl.py`](scripts/csv2tbl.py) | Converts a 010 editor CSV encoding file into a table file |
 
 ### Pattern Libraries
 
 | Name | Path | Description |
 |------|------|-------------|
-| libstd | `includes/std/*` | Pattern Language Standard Libaray |
-| cstdint | `includes/cstdint.pat` | C integer types |
+| 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
 
 | Name | Path | Description |
 |------|------|-------------|
-| Official Rules | `yara/official_rules/*` | Official Yara rules repository |
+| Official Rules | [`yara/official_rules/*`](yara/official_rules) | Official Yara rules repository |
 
 ### Magic files
 
 | Name | Path | Description |
 |------|------|-------------|
-| Nintendo Switch | `magic/nintendo_switch_magic` | Identifies common file types used on the Nintendo Switch |
-| Portable Executable | `magic/portable_executable_magic` | Identifies PE files used on Windows
+| Nintendo Switch | [`magic/nintendo_switch_magic`](magic/nintendo_switch_magic) | Identifies common file types used on the Nintendo Switch |
+| Portable Executable | [`magic/portable_executable_magic`](magic/portable_executable_magic) | Identifies PE files used on Windows
 
 ### Constants files
 
 | Name | Path | Description |
 |------|------|-------------|
-| CRC-16 | `constants/crc16.json` | Constants associated with CRC-16 operations |
-| CRC-32 | `constants/crc32.json` | Constants associated with CRC-32 operations |
-| HTTP-Codes | `constants/http_status.json` | HTTP Status code values |
-| Linux Error Codes | `constants/linux_errors.json` | Values of Linux error results |
+| CRC-16 | [`constants/crc16.json`](constants/crc16.json) | Constants associated with CRC-16 operations |
+| CRC-32 | [`constants/crc32.json`](constants/crc32.json) | Constants associated with CRC-32 operations |
+| HTTP-Codes | [`constants/http_status.json`](constants/http_status.json) | HTTP Status code values |
+| Linux Error Codes | [`constants/linux_errors.json`](constants/linux_errors.json) | Values of Linux error results |
 
 ### Encoding files
 
 | Name | Path | Description |
 |------|------|-------------|
-| ANSI | `encodings/ansi.tbl` | ANSI encoding |
-| EUC-JP | `encodings/euc_jp.tbl` | EUC-JP encoding with NEC special and IBM extended characters |
-| ISO/IEC 646 | `encodings/iso_646.tbl` | ISO/IEC 646 encoding, an older version of ASCII |
-| ISO/IEC 6937 | `encodings/iso_6937.tbl` | ISO/IEC 6937 encoding, an extension of ASCII containing additional character |
-| Shift-JIS with half-width characters | `encodings/shiftjis_halfchars.tbl` | Shift-JIS encoding including half-width characters at 0xA1 - 0xDF |
-| Shift-JIS UTF-8 | `encodings/shiftjis.tbl` | Shift-JIS encoding in UTF-8 |
-| JIS 0201 | `encodings/jis_x_0201.tbl` | JIS X 0201 encoding in UTF-8 |
-| JIS X 0211 | `encodings/jis_x_0211.tbl` | JIS X 0211 encoding in UTF-8 |
-| JIS 0213 | `encodings/jis_x_0213.tbl` | JIS X 0213 encoding in UTF-8 |
+| Arabic ISO | [`encodings/arabic_iso.tbl`](encodings/arabic_iso.tbl) | Arabic ISO encoding |
+| Arabic Windows | [`encodings/arabic_windows.tbl`](encodings/arabic_windows.tbl) | Arabic Windows encoding |
+| ASCII | [`encodings/ascii.tbl`](encodings/ascii.tbl) | Regular ASCII encoding |
+| ASCII+ANSI | [`encodings/ascii_ansi.tbl`](encodings/ascii_ansi.tbl) | Extended ASCII encoding |
+| 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) |
+| Cyrillic KOI8-U | [`encodings/cyrillic_koi8_u.tbl`](encodings/cyrillic_koi8_u.tbl) | Cyrillic KOI8-U encoding (Ukranian Characters) |
+| Eastern Europe ISO | [`encodings/eastern_europe_iso.tbl`](encodings/eastern_europe_iso.tbl) | Eastern Europe ISO encoding |
+| Eastern Europe Windows | [`encodings/eastern_europe_windows.tbl`](encodings/eastern_europe_windows.tbl) | Eastern Europe Windows encoding |
+| EBCDIC | [`encodings/ebcdic.tbl`](encodings/ebcdic.tbl) | Extended Binary Coded Decimal Interchange Code, developed by IBM for their Main Frames |
+| EUC-JP | [`encodings/euc_jp.tbl`](encodings/euc_jp.tbl) | EUC-JP encoding with NEC special and IBM extended characters |
+| EUC-KR | [`encodings/euc_kr.tbl`](encodings/euc_kr.tbl) | EUC-KR encoding |
+| Greek ISO | [`encodings/greek_iso.tbl`](encodings/greek_iso.tbl) | Greek ISO encoding |
+| Greek Windows | [`encodings/greek_windows.tbl`](encodings/greek_windows.tbl) | Greek Windows encoding |
+| Hebrew ISO | [`encodings/hebrew_iso.tbl`](encodings/hebrew_iso.tbl) | Hebrew ISO encoding |
+| Hebrew Windows | [`encodings/hebrew_windows.tbl`](encodings/hebrew_windows.tbl) | Hebrew Windows encoding |
+| ISO/IEC 646 | [`encodings/iso_646.tbl`](encodings/iso_646.tbl) | ISO/IEC 646 encoding, an older version of ASCII |
+| ISO/IEC 6937 | [`encodings/iso_6937.tbl`](encodings/iso_6937.tbl) | ISO/IEC 6937 encoding, an extension of ASCII containing additional character |
+| JIS 0201 | [`encodings/jis_x_0201.tbl`](encodings/jis_x_0201.tbl) | JIS X 0201 encoding in UTF-8 |
+| JIS X 0211 | [`encodings/jis_x_0211.tbl`](encodings/jis_x_0211.tbl) | JIS X 0211 encoding in UTF-8 |
+| JIS 0213 | [`encodings/jis_x_0213.tbl`](encodings/jis_x_0213.tbl) | JIS X 0213 encoding in UTF-8 |
+| Macintosh | [`encodings/macintosh.tbl`](encodings/macintosh.tbl) | Macintosh character encoding used by the Kermit protocol |
+| Pokémon (English, Generation 1) | [`encodings/pokegen1_en.tbl`](encodings/pokegen1_en.tbl) | Character encoding used by the English generation 1 Pokémon games  |
+| Pokémon (English, Generation 3) | [`encodings/pokegen3_en.tbl`](encodings/pokegen3_en.tbl) | Character encoding used by the English generation 3 Pokémon games  |
+| Shift-JIS UTF-8 | [`encodings/shiftjis.tbl`](encodings/shiftjis.tbl) | Shift-JIS encoding in UTF-8 |
+| Thai | [`encodings/thai.tbl`](encodings/thai.tbl) | Thai character encoding |
+| Turkish ISO | [`encodings/turkish_iso.tbl`](encodings/turkish_iso.tbl) | Turkish ISO encoding |
+| Turkish Windows | [`encodings/turkish_windows.tbl`](encodings/turkish_windows.tbl) | Turkish Windows encoding |
+| UTF-8 | [`encodings/utf8.tbl`](encodings/utf8.tbl) | UTF-8 encoding |
+| Vietnamese | [`encodings/vietnamese.tbl`](encodings/vietnamese.tbl) | Vietnamese character encoding |
 
-## Contributing
+### Data Processor Nodes
 
-If you want to contribute a file to the database, please make a PR which adds it to the right folder and adds a new entry to the table in this readme. 
-To take advantage of the automatic pattern testing, please consider adding a test file named `<pattern_name>.hexpat.<extension>` to the `/tests/patterns/test_data` directory. Try to keep this file as small as possible so the repository doesn't become excessively large
+| 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 |
 
-Thanks a lot :)
+### Themes
+
+| Name | Path | Description |
+|------|------|-------------|
+| Visual Studio Dark | [`themes/vs_dark.json`](themes/vs_dark.json) | Theme similar to Visual Studio's Dark theme |
+| Solarized Dark | [`themes/solarized_dark.json`](themes/solarized_dark.json) | Solarized Dark Theme |
+| Catppuccin Latte | [`themes/catppuccin-latte.json`](themes/catppuccin-latte.json) | Catppuccin Latte Flavor (Light Theme) |
+| 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) |
+
+### 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"
+                    }
+                }
+            ]
+        }
+
+    ]
+}

encodings/ansi.tbl

@@ -1,255 +0,0 @@
-*0D0A
-00
-01
-02
-03
-04
-05
-06
-07
-0B
-0C
-0E
-0F
-10
-11
-12
-13
-14
-15
-16
-17
-18
-19
-1A
-1B
-1C
-1D
-1E
-1F
-7E
-7F
-80
-81
-82
-83
-84
-85
-86
-87
-88
-89
-8A
-8B
-8C
-8D
-8E
-8F
-90
-93 
-94	
-95
-96
-97
-98
-99
-9A
-9B
-9C
-9D
-9E
-B7
-08=BackSpace
-09=\t
-20= 
-21=!
-22="
-23=#
-24=$
-25=%
-26=&
-27='
-28=(
-29=)
-2A=*
-2B=+
-2C=,
-2D=-
-2E=.
-2F=/
-30=0
-31=1
-32=2
-33=3
-34=4
-35=5
-36=6
-37=7
-38=8
-39=9
-3A=:
-3B=;
-3C=<
-3D==
-3E=>
-3F=?
-40=@
-41=A
-42=B
-43=C
-44=D
-45=E
-46=F
-47=G
-48=H
-49=I
-4A=J
-4B=K
-4C=L
-4D=M
-4E=N
-4F=O
-50=P
-51=Q
-52=R
-53=S
-54=T
-55=U
-56=V
-57=W
-58=X
-59=Y
-5A=Z
-5B=[
-5C=\
-5D=]
-5E=^
-5F=_
-60=`
-61=a
-62=b
-63=c
-64=d
-65=e
-66=f
-67=g
-68=h
-69=i
-6A=j
-6B=k
-6C=l
-6D=m
-6E=n
-6F=o
-70=p
-71=q
-72=r
-73=s
-74=t
-75=u
-76=v
-77=w
-78=x
-79=y
-7A=z
-7B={
-7C=|
-7D=}
-91='
-92='
-9F==<3D>
-A0= 
-A1=<3D>
-A2=<3D>
-A3=<3D>
-A4=<3D>
-A5=<3D>
-A6=<3D>
-A7=<3D>
-A8=<3D>
-A9=<3D>
-AA=<3D>
-AB=<3D>
-AC=<3D>
-AD=<3D>
-AE=<3D>
-AF=<3D>
-B0=<3D>
-B1=<3D>
-B2=<3D>
-B3=<3D>
-B4=<3D>
-B5=<3D>
-B6=<3D>
-B8=<3D>
-B9=<3D>
-BA=<3D>
-BB=<3D>
-BC=<3D>
-BD=<3D>
-BE=<3D>
-BF=<3D>
-C0=A
-C1=<3D>
-C2=<3D>
-C3=<3D>
-C4=<3D>
-C5=<3D>
-C6=<3D>
-C7=<3D>
-C8=<3D>
-C9=<3D>
-CA=<3D>
-CB=<3D>
-CC=<3D>
-CD=<3D>
-CE=<3D>
-CF=<3D>
-D0=<3D>
-D1=<3D>
-D2=<3D>
-D3=<3D>
-D4=<3D>
-D5=<3D>
-D6=<3D>
-D7=<3D>
-D8=<3D>
-D9=<3D>
-DA=<3D>
-DB=<3D>
-DC=<3D>
-DD=<3D>
-DE=<3D>
-DF=<3D>
-E0=<3D>
-E1=<3D>
-E2=<3D>
-E3=<3D>
-E4=<3D>
-E5=<3D>
-E6=<3D>
-E7=<3D>
-E8=<3D>
-E9=<3D>
-EA=<3D>
-EB=<3D>
-EC=<3D>
-ED=<3D>
-EE=<3D>
-EF=<3D>
-F0=<3D>
-F1=<3D>
-F2=<3D>
-F3=<3D>
-F4=<3D>
-F5=<3D>
-F6=<3D>
-F7=<3D>
-F8=<3D>
-F9=<3D>
-FA=<3D>
-FB=<3D>
-FC=<3D>
-FD=<3D>
-FE=<3D>
-FF=<3D>

encodings/arabic_iso.tbl

@@ -0,0 +1,256 @@
+00=NUL
+01=SOH
+02=STX
+03=ETX
+04=EOT
+05=ENQ
+06=ACK
+07=BEL
+08=BS
+09=TAB
+0A=LF
+0B=VT
+0C=FF
+0D=CR
+0E=SO
+0F=SI
+10=DLE
+11=DC1
+12=DC2
+13=DC3
+14=DC4
+15=NAK
+16=SYN
+17=ETB
+18=CAN
+19=EM
+1A=SUB
+1B=ESC
+1C=FS
+1D=GS
+1E=RS
+1F=US
+20= 
+21=!
+22="
+23=#
+24=$
+25=%
+26=&
+27='
+28=(
+29=)
+2A=*
+2B=+
+2C=,
+2D=-
+2E=.
+2F=/
+30=0
+31=1
+32=2
+33=3
+34=4
+35=5
+36=6
+37=7
+38=8
+39=9
+3A=:
+3B=;
+3C=<
+3D==
+3E=>
+3F=?
+40=@
+41=A
+42=B
+43=C
+44=D
+45=E
+46=F
+47=G
+48=H
+49=I
+4A=J
+4B=K
+4C=L
+4D=M
+4E=N
+4F=O
+50=P
+51=Q
+52=R
+53=S
+54=T
+55=U
+56=V
+57=W
+58=X
+59=Y
+5A=Z
+5B=[
+5C=\
+5D=]
+5E=^
+5F=_
+60=`
+61=a
+62=b
+63=c
+64=d
+65=e
+66=f
+67=g
+68=h
+69=i
+6A=j
+6B=k
+6C=l
+6D=m
+6E=n
+6F=o
+70=p
+71=q
+72=r
+73=s
+74=t
+75=u
+76=v
+77=w
+78=x
+79=y
+7A=z
+7B={
+7C=|
+7D=}
+7E=~
+7F=DEL
+80=€
+81=
+82=‚
+83=ƒ
+84=„
+85=…
+86=†
+87=‡
+88=ˆ
+89=‰
+8A=Š
+8B=‹
+8C=Œ
+8D=
+8E=Ž
+8F=
+90=
+91=‘
+92=’
+93=“
+94=”
+95=•
+96=–
+97=—
+98=˜
+99=™
+9A=š
+9B=›
+9C=œ
+9D=
+9E=ž
+9F=Ÿ
+A0= 
+A1
+A2
+A3
+A4=¤
+A5
+A6
+A7
+A8
+A9
+AA
+AB
+AC=،
+AD=­
+AE
+AF
+B0
+B1
+B2
+B3
+B4
+B5
+B6
+B7
+B8
+B9
+BA
+BB=؛
+BC
+BD
+BE
+BF=؟
+C0
+C1=ء
+C2=آ
+C3=أ
+C4=ؤ
+C5=إ
+C6=ئ
+C7=ا
+C8=ب
+C9=ة
+CA=ت
+CB=ث
+CC=ج
+CD=ح
+CE=خ
+CF=د
+D0=ذ
+D1=ر
+D2=ز
+D3=س
+D4=ش
+D5=ص
+D6=ض
+D7=ط
+D8=ظ
+D9=ع
+DA=غ
+DB
+DC
+DD
+DE
+DF
+E0=ـ
+E1=ف
+E2=ق
+E3=ك
+E4=ل
+E5=م
+E6=ن
+E7=ه
+E8=و
+E9=ى
+EA=ي
+EB=ً
+EC=ٌ
+ED=ٍ
+EE=َ
+EF=ُ
+F0=ِ
+F1=ّ
+F2=ْ
+F3
+F4
+F5
+F6
+F7
+F8
+F9
+FA
+FB
+FC
+FD
+FE
+FF

encodings/arabic_windows.tbl

@@ -0,0 +1,256 @@
+00=NUL
+01=SOH
+02=STX
+03=ETX
+04=EOT
+05=ENQ
+06=ACK
+07=BEL
+08=BS
+09=TAB
+0A=LF
+0B=VT
+0C=FF
+0D=CR
+0E=SO
+0F=SI
+10=DLE
+11=DC1
+12=DC2
+13=DC3
+14=DC4
+15=NAK
+16=SYN
+17=ETB
+18=CAN
+19=EM
+1A=SUB
+1B=ESC
+1C=FS
+1D=GS
+1E=RS
+1F=US
+20= 
+21=!
+22="
+23=#
+24=$
+25=%
+26=&
+27='
+28=(
+29=)
+2A=*
+2B=+
+2C=,
+2D=-
+2E=.
+2F=/
+30=0
+31=1
+32=2
+33=3
+34=4
+35=5
+36=6
+37=7
+38=8
+39=9
+3A=:
+3B=;
+3C=<
+3D==
+3E=>
+3F=?
+40=@
+41=A
+42=B
+43=C
+44=D
+45=E
+46=F
+47=G
+48=H
+49=I
+4A=J
+4B=K
+4C=L
+4D=M
+4E=N
+4F=O
+50=P
+51=Q
+52=R
+53=S
+54=T
+55=U
+56=V
+57=W
+58=X
+59=Y
+5A=Z
+5B=[
+5C=\
+5D=]
+5E=^
+5F=_
+60=`
+61=a
+62=b
+63=c
+64=d
+65=e
+66=f
+67=g
+68=h
+69=i
+6A=j
+6B=k
+6C=l
+6D=m
+6E=n
+6F=o
+70=p
+71=q
+72=r
+73=s
+74=t
+75=u
+76=v
+77=w
+78=x
+79=y
+7A=z
+7B={
+7C=|
+7D=}
+7E=~
+7F=DEL
+80=€
+81=پ
+82=‚
+83=ƒ
+84=„
+85=…
+86=†
+87=‡
+88=ˆ
+89=‰
+8A=ٹ
+8B=‹
+8C=Œ
+8D=چ
+8E=ژ
+8F=ڈ
+90=گ
+91=‘
+92=’
+93=“
+94=”
+95=•
+96=–
+97=—
+98=ک
+99=™
+9A=ڑ
+9B=›
+9C=œ
+9D=‌
+9E=‍
+9F=ں
+A0= 
+A1=،
+A2=¢
+A3=£
+A4=¤
+A5=¥
+A6=¦
+A7=§
+A8=¨
+A9=©
+AA=ھ
+AB=«
+AC=¬
+AD=­
+AE=®
+AF=¯
+B0=°
+B1=±
+B2=²
+B3=³
+B4=´
+B5=µ
+B6=¶
+B7=·
+B8=¸
+B9=¹
+BA=؛
+BB=»
+BC=¼
+BD=½
+BE=¾
+BF=؟
+C0=ہ
+C1=ء
+C2=آ
+C3=أ
+C4=ؤ
+C5=إ
+C6=ئ
+C7=ا
+C8=ب
+C9=ة
+CA=ت
+CB=ث
+CC=ج
+CD=ح
+CE=خ
+CF=د
+D0=ذ
+D1=ر
+D2=ز
+D3=س
+D4=ش
+D5=ص
+D6=ض
+D7=×
+D8=ط
+D9=ظ
+DA=ع
+DB=غ
+DC=ـ
+DD=ف
+DE=ق
+DF=ك
+E0=à
+E1=ل
+E2=â
+E3=م
+E4=ن
+E5=ه
+E6=و
+E7=ç
+E8=è
+E9=é
+EA=ê
+EB=ë
+EC=ى
+ED=ي
+EE=î
+EF=ï
+F0=ً
+F1=ٌ
+F2=ٍ
+F3=َ
+F4=ô
+F5=ُ
+F6=ِ
+F7=÷
+F8=ّ
+F9=ù
+FA=ْ
+FB=û
+FC=ü
+FD=‎
+FE=‏
+FF=ے

encodings/ascii.tbl

@@ -0,0 +1,256 @@
+00=NUL
+01=SOH
+02=STX
+03=ETX
+04=EOT
+05=ENQ
+06=ACK
+07=BEL
+08=BS
+09=TAB
+0A=LF
+0B=VT
+0C=FF
+0D=CR
+0E=SO
+0F=SI
+10=DLE
+11=DC1
+12=DC2
+13=DC3
+14=DC4
+15=NAK
+16=SYN
+17=ETB
+18=CAN
+19=EM
+1A=SUB
+1B=ESC
+1C=FS
+1D=GS
+1E=RS
+1F=US
+20= 
+21=!
+22="
+23=#
+24=$
+25=%
+26=&
+27='
+28=(
+29=)
+2A=*
+2B=+
+2C=,
+2D=-
+2E=.
+2F=/
+30=0
+31=1
+32=2
+33=3
+34=4
+35=5
+36=6
+37=7
+38=8
+39=9
+3A=:
+3B=;
+3C=<
+3D==
+3E=>
+3F=?
+40=@
+41=A
+42=B
+43=C
+44=D
+45=E
+46=F
+47=G
+48=H
+49=I
+4A=J
+4B=K
+4C=L
+4D=M
+4E=N
+4F=O
+50=P
+51=Q
+52=R
+53=S
+54=T
+55=U
+56=V
+57=W
+58=X
+59=Y
+5A=Z
+5B=[
+5C=\
+5D=]
+5E=^
+5F=_
+60=`
+61=a
+62=b
+63=c
+64=d
+65=e
+66=f
+67=g
+68=h
+69=i
+6A=j
+6B=k
+6C=l
+6D=m
+6E=n
+6F=o
+70=p
+71=q
+72=r
+73=s
+74=t
+75=u
+76=v
+77=w
+78=x
+79=y
+7A=z
+7B={
+7C=|
+7D=}
+7E=~
+7F=DEL
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+8A
+8B
+8C
+8D
+8E
+8F
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+9A
+9B
+9C
+9D
+9E
+9F
+A0
+A1
+A2
+A3
+A4
+A5
+A6
+A7
+A8
+A9
+AA
+AB
+AC
+AD
+AE
+AF
+B0
+B1
+B2
+B3
+B4
+B5
+B6
+B7
+B8
+B9
+BA
+BB
+BC
+BD
+BE
+BF
+C0
+C1
+C2
+C3
+C4
+C5
+C6
+C7
+C8
+C9
+CA
+CB
+CC
+CD
+CE
+CF
+D0
+D1
+D2
+D3
+D4
+D5
+D6
+D7
+D8
+D9
+DA
+DB
+DC
+DD
+DE
+DF
+E0
+E1
+E2
+E3
+E4
+E5
+E6
+E7
+E8
+E9
+EA
+EB
+EC
+ED
+EE
+EF
+F0
+F1
+F2
+F3
+F4
+F5
+F6
+F7
+F8
+F9
+FA
+FB
+FC
+FD
+FE
+FF

encodings/ascii_ansi.tbl

@@ -0,0 +1,256 @@
+00=NUL
+01=SOH
+02=STX
+03=ETX
+04=EOT
+05=ENQ
+06=ACK
+07=BEL
+08=BS
+09=TAB
+0A=LF
+0B=VT
+0C=FF
+0D=CR
+0E=SO
+0F=SI
+10=DLE
+11=DC1
+12=DC2
+13=DC3
+14=DC4
+15=NAK
+16=SYN
+17=ETB
+18=CAN
+19=EM
+1A=SUB
+1B=ESC
+1C=FS
+1D=GS
+1E=RS
+1F=US
+20= 
+21=!
+22="
+23=#
+24=$
+25=%
+26=&
+27='
+28=(
+29=)
+2A=*
+2B=+
+2C=,
+2D=-
+2E=.
+2F=/
+30=0
+31=1
+32=2
+33=3
+34=4
+35=5
+36=6
+37=7
+38=8
+39=9
+3A=:
+3B=;
+3C=<
+3D==
+3E=>
+3F=?
+40=@
+41=A
+42=B
+43=C
+44=D
+45=E
+46=F
+47=G
+48=H
+49=I
+4A=J
+4B=K
+4C=L
+4D=M
+4E=N
+4F=O
+50=P
+51=Q
+52=R
+53=S
+54=T
+55=U
+56=V
+57=W
+58=X
+59=Y
+5A=Z
+5B=[
+5C=\
+5D=]
+5E=^
+5F=_
+60=`
+61=a
+62=b
+63=c
+64=d
+65=e
+66=f
+67=g
+68=h
+69=i
+6A=j
+6B=k
+6C=l
+6D=m
+6E=n
+6F=o
+70=p
+71=q
+72=r
+73=s
+74=t
+75=u
+76=v
+77=w
+78=x
+79=y
+7A=z
+7B={
+7C=|
+7D=}
+7E=~
+7F=DEL
+80=€
+81
+82=‚
+83=ƒ
+84=„
+85=…
+86=†
+87=‡
+88=ˆ
+89=‰
+8A=Š
+8B=‹
+8C=Œ
+8D
+8E=Ž
+8F
+90
+91=‘
+92=’
+93=“
+94=”
+95=•
+96=–
+97=—
+98=˜
+99=™
+9A=š
+9B=›
+9C=œ
+9D
+9E=ž
+9F=Ÿ
+A0= 
+A1=¡
+A2=¢
+A3=£
+A4=¤
+A5=¥
+A6=¦
+A7=§
+A8=¨
+A9=©
+AA=ª
+AB=«
+AC=¬
+AD=­
+AE=®
+AF=¯
+B0=°
+B1=±
+B2=²
+B3=³
+B4=´
+B5=µ
+B6=¶
+B7=·
+B8=¸
+B9=¹
+BA=º
+BB=»
+BC=¼
+BD=½
+BE=¾
+BF=¿
+C0=À
+C1=Á
+C2=Â
+C3=Ã
+C4=Ä
+C5=Å
+C6=Æ
+C7=Ç
+C8=È
+C9=É
+CA=Ê
+CB=Ë
+CC=Ì
+CD=Í
+CE=Î
+CF=Ï
+D0=Ð
+D1=Ñ
+D2=Ò
+D3=Ó
+D4=Ô
+D5=Õ
+D6=Ö
+D7=×
+D8=Ø
+D9=Ù
+DA=Ú
+DB=Û
+DC=Ü
+DD=Ý
+DE=Þ
+DF=ß
+E0=à
+E1=á
+E2=â
+E3=ã
+E4=ä
+E5=å
+E6=æ
+E7=ç
+E8=è
+E9=é
+EA=ê
+EB=ë
+EC=ì
+ED=í
+EE=î
+EF=ï
+F0=ð
+F1=ñ
+F2=ò
+F3=ó
+F4=ô
+F5=õ
+F6=ö
+F7=÷
+F8=ø
+F9=ù
+FA=ú
+FB=û
+FC=ü
+FD=ý
+FE=þ
+FF=ÿ

encodings/ascii_oem.tbl

@@ -0,0 +1,256 @@
+00=NUL
+01=SOH
+02=STX
+03=ETX
+04=EOT
+05=ENQ
+06=ACK
+07=BEL
+08=BS
+09=TAB
+0A=LF
+0B=VT
+0C=FF
+0D=CR
+0E=SO
+0F=SI
+10=DLE
+11=DC1
+12=DC2
+13=DC3
+14=DC4
+15=NAK
+16=SYN
+17=ETB
+18=CAN
+19=EM
+1A=SUB
+1B=ESC
+1C=FS
+1D=GS
+1E=RS
+1F=US
+20= 
+21=!
+22="
+23=#
+24=$
+25=%
+26=&
+27='
+28=(
+29=)
+2A=*
+2B=+
+2C=,
+2D=-
+2E=.
+2F=/
+30=0
+31=1
+32=2
+33=3
+34=4
+35=5
+36=6
+37=7
+38=8
+39=9
+3A=:
+3B=;
+3C=<
+3D==
+3E=>
+3F=?
+40=@
+41=A
+42=B
+43=C
+44=D
+45=E
+46=F
+47=G
+48=H
+49=I
+4A=J
+4B=K
+4C=L
+4D=M
+4E=N
+4F=O
+50=P
+51=Q
+52=R
+53=S
+54=T
+55=U
+56=V
+57=W
+58=X
+59=Y
+5A=Z
+5B=[
+5C=\
+5D=]
+5E=^
+5F=_
+60=`
+61=a
+62=b
+63=c
+64=d
+65=e
+66=f
+67=g
+68=h
+69=i
+6A=j
+6B=k
+6C=l
+6D=m
+6E=n
+6F=o
+70=p
+71=q
+72=r
+73=s
+74=t
+75=u
+76=v
+77=w
+78=x
+79=y
+7A=z
+7B={
+7C=|
+7D=}
+7E=~
+7F=DEL
+80=Ç
+81=ü
+82=é
+83=â
+84=ä
+85=à
+86=å
+87=ç
+88=ê
+89=ë
+8A=è
+8B=ï
+8C=î
+8D=ì
+8E=Ä
+8F=Å
+90=É
+91=æ
+92=Æ
+93=ô
+94=ö
+95=ò
+96=û
+97=ù
+98=ÿ
+99=Ö
+9A=Ü
+9B=¢
+9C=£
+9D=¥
+9E=₧
+9F=ƒ
+A0=á
+A1=í
+A2=ó
+A3=ú
+A4=ñ
+A5=Ñ
+A6=ª
+A7=º
+A8=¿
+A9=⌐
+AA=¬
+AB=½
+AC=¼
+AD=¡
+AE=«
+AF=»
+B0=░
+B1=▒
+B2=▓
+B3=│
+B4=┤
+B5=╡
+B6=╢
+B7=╖
+B8=╕
+B9=╣
+BA=║
+BB=╗
+BC=╝
+BD=╜
+BE=╛
+BF=┐
+C0=└
+C1=┴
+C2=┬
+C3=├
+C4=─
+C5=┼
+C6=╞
+C7=╟
+C8=╚
+C9=╔
+CA=╩
+CB=╦
+CC=╠
+CD=═
+CE=╬
+CF=╧
+D0=╨
+D1=╤
+D2=╥
+D3=╙
+D4=╘
+D5=╒
+D6=╓
+D7=╫
+D8=╪
+D9=┘
+DA=┌
+DB=█
+DC=▄
+DD=▌
+DE=▐
+DF=▀
+E0=α
+E1=ß
+E2=Γ
+E3=π
+E4=Σ
+E5=σ
+E6=µ
+E7=τ
+E8=Φ
+E9=Θ
+EA=Ω
+EB=δ
+EC=∞
+ED=φ
+EE=ε
+EF=∩
+F0=≡
+F1=±
+F2=≥
+F3=≤
+F4=⌠
+F5=⌡
+F6=÷
+F7=≈
+F8=°
+F9=∙
+FA=·
+FB=√
+FC=ⁿ
+FD=²
+FE=■
+FF= 

encodings/baltic_iso.tbl

@@ -0,0 +1,256 @@
+00=NUL
+01=SOH
+02=STX
+03=ETX
+04=EOT
+05=ENQ
+06=ACK
+07=BEL
+08=BS
+09=TAB
+0A=LF
+0B=VT
+0C=FF
+0D=CR
+0E=SO
+0F=SI
+10=DLE
+11=DC1
+12=DC2
+13=DC3
+14=DC4
+15=NAK
+16=SYN
+17=ETB
+18=CAN
+19=EM
+1A=SUB
+1B=ESC
+1C=FS
+1D=GS
+1E=RS
+1F=US
+20= 
+21=!
+22="
+23=#
+24=$
+25=%
+26=&
+27='
+28=(
+29=)
+2A=*
+2B=+
+2C=,
+2D=-
+2E=.
+2F=/
+30=0
+31=1
+32=2
+33=3
+34=4
+35=5
+36=6
+37=7
+38=8
+39=9
+3A=:
+3B=;
+3C=<
+3D==
+3E=>
+3F=?
+40=@
+41=A
+42=B
+43=C
+44=D
+45=E
+46=F
+47=G
+48=H
+49=I
+4A=J
+4B=K
+4C=L
+4D=M
+4E=N
+4F=O
+50=P
+51=Q
+52=R
+53=S
+54=T
+55=U
+56=V
+57=W
+58=X
+59=Y
+5A=Z
+5B=[
+5C=\
+5D=]
+5E=^
+5F=_
+60=`
+61=a
+62=b
+63=c
+64=d
+65=e
+66=f
+67=g
+68=h
+69=i
+6A=j
+6B=k
+6C=l
+6D=m
+6E=n
+6F=o
+70=p
+71=q
+72=r
+73=s
+74=t
+75=u
+76=v
+77=w
+78=x
+79=y
+7A=z
+7B={
+7C=|
+7D=}
+7E=~
+7F=DEL
+80=€
+81=
+82=‚
+83=ƒ
+84=„
+85=…
+86=†
+87=‡
+88=ˆ
+89=‰
+8A=Š
+8B=‹
+8C=Œ
+8D=
+8E=Ž
+8F=
+90=
+91=‘
+92=’
+93=“
+94=”
+95=•
+96=–
+97=—
+98=˜
+99=™
+9A=š
+9B=›
+9C=œ
+9D=
+9E=ž
+9F=Ÿ
+A0= 
+A1=”
+A2=¢
+A3=£
+A4=¤
+A5=„
+A6=¦
+A7=§
+A8=Ø
+A9=©
+AA=Ŗ
+AB=«
+AC=¬
+AD=­
+AE=®
+AF=Æ
+B0=°
+B1=±
+B2=²
+B3=³
+B4=“
+B5=µ
+B6=¶
+B7=·
+B8=ø
+B9=¹
+BA=ŗ
+BB=»
+BC=¼
+BD=½
+BE=¾
+BF=æ
+C0=Ą
+C1=Į
+C2=Ā
+C3=Ć
+C4=Ä
+C5=Å
+C6=Ę
+C7=Ē
+C8=Č
+C9=É
+CA=Ź
+CB=Ė
+CC=Ģ
+CD=Ķ
+CE=Ī
+CF=Ļ
+D0=Š
+D1=Ń
+D2=Ņ
+D3=Ó
+D4=Ō
+D5=Õ
+D6=Ö
+D7=×
+D8=Ų
+D9=Ł
+DA=Ś
+DB=Ū
+DC=Ü
+DD=Ż
+DE=Ž
+DF=ß
+E0=ą
+E1=į
+E2=ā
+E3=ć
+E4=ä
+E5=å
+E6=ę
+E7=ē
+E8=č
+E9=é
+EA=ź
+EB=ė
+EC=ģ
+ED=ķ
+EE=ī
+EF=ļ
+F0=š
+F1=ń
+F2=ņ
+F3=ó
+F4=ō
+F5=õ
+F6=ö
+F7=÷
+F8=ų
+F9=ł
+FA=ś
+FB=ū
+FC=ü
+FD=ż
+FE=ž
+FF=’

encodings/baltic_windows.tbl

@@ -0,0 +1,256 @@
+00=NUL
+01=SOH
+02=STX
+03=ETX
+04=EOT
+05=ENQ
+06=ACK
+07=BEL
+08=BS
+09=TAB
+0A=LF
+0B=VT
+0C=FF
+0D=CR
+0E=SO
+0F=SI
+10=DLE
+11=DC1
+12=DC2
+13=DC3
+14=DC4
+15=NAK
+16=SYN
+17=ETB
+18=CAN
+19=EM
+1A=SUB
+1B=ESC
+1C=FS
+1D=GS
+1E=RS
+1F=US
+20= 
+21=!
+22="
+23=#
+24=$
+25=%
+26=&
+27='
+28=(
+29=)
+2A=*
+2B=+
+2C=,
+2D=-
+2E=.
+2F=/
+30=0
+31=1
+32=2
+33=3
+34=4
+35=5
+36=6
+37=7
+38=8
+39=9
+3A=:
+3B=;
+3C=<
+3D==
+3E=>
+3F=?
+40=@
+41=A
+42=B
+43=C
+44=D
+45=E
+46=F
+47=G
+48=H
+49=I
+4A=J
+4B=K
+4C=L
+4D=M
+4E=N
+4F=O
+50=P
+51=Q
+52=R
+53=S
+54=T
+55=U
+56=V
+57=W
+58=X
+59=Y
+5A=Z
+5B=[
+5C=\
+5D=]
+5E=^
+5F=_
+60=`
+61=a
+62=b
+63=c
+64=d
+65=e
+66=f
+67=g
+68=h
+69=i
+6A=j
+6B=k
+6C=l
+6D=m
+6E=n
+6F=o
+70=p
+71=q
+72=r
+73=s
+74=t
+75=u
+76=v
+77=w
+78=x
+79=y
+7A=z
+7B={
+7C=|
+7D=}
+7E=~
+7F=DEL
+80=€
+81
+82=‚
+83
+84=„
+85=…
+86=†
+87=‡
+88
+89=‰
+8A
+8B=‹
+8C
+8D=¨
+8E=ˇ
+8F=¸
+90
+91=‘
+92=’
+93=“
+94=”
+95=•
+96=–
+97=—
+98
+99=™
+9A
+9B=›
+9C
+9D=¯
+9E=˛
+9F
+A0= 
+A1
+A2=¢
+A3=£
+A4=¤
+A5
+A6=¦
+A7=§
+A8=Ø
+A9=©
+AA=Ŗ
+AB=«
+AC=¬
+AD=­
+AE=®
+AF=Æ
+B0=°
+B1=±
+B2=²
+B3=³
+B4=´
+B5=µ
+B6=¶
+B7=·
+B8=ø
+B9=¹
+BA=ŗ
+BB=»
+BC=¼
+BD=½
+BE=¾
+BF=æ
+C0=Ą
+C1=Į
+C2=Ā
+C3=Ć
+C4=Ä
+C5=Å
+C6=Ę
+C7=Ē
+C8=Č
+C9=É
+CA=Ź
+CB=Ė
+CC=Ģ
+CD=Ķ
+CE=Ī
+CF=Ļ
+D0=Š
+D1=Ń
+D2=Ņ
+D3=Ó
+D4=Ō
+D5=Õ
+D6=Ö
+D7=×
+D8=Ų
+D9=Ł
+DA=Ś
+DB=Ū
+DC=Ü
+DD=Ż
+DE=Ž
+DF=ß
+E0=ą
+E1=į
+E2=ā
+E3=ć
+E4=ä
+E5=å
+E6=ę
+E7=ē
+E8=č
+E9=é
+EA=ź
+EB=ė
+EC=ģ
+ED=ķ
+EE=ī
+EF=ļ
+F0=š
+F1=ń
+F2=ņ
+F3=ó
+F4=ō
+F5=õ
+F6=ö
+F7=÷
+F8=ų
+F9=ł
+FA=ś
+FB=ū
+FC=ü
+FD=ż
+FE=ž
+FF=˙

encodings/cyrillic_cp866.tbl

@@ -0,0 +1,256 @@
+00=NUL
+01=☺
+02=☻
+03=♥
+04=♦
+05=♣
+06=♠
+07=•
+08=◘
+09=○
+0A=◙
+0B=♂
+0C=♀
+0D=♪
+0E=♫
+0F=☼
+10=►
+11=◄
+12=↕
+13=‼
+14=¶
+15=§
+16=▬
+17=↨
+18=↑
+19=↓
+1A=→
+1B=←
+1C=∟
+1D=↔
+1E=▲
+1F=▼
+20= 
+21=!
+22="
+23=#
+24=$
+25=%
+26=&
+27='
+28=(
+29=)
+2A=*
+2B=+
+2C=,
+2D=-
+2E=.
+2F=/
+30=0
+31=1
+32=2
+33=3
+34=4
+35=5
+36=6
+37=7
+38=8
+39=9
+3A=:
+3B=;
+3C=<
+3D==
+3E=>
+3F=?
+40=@
+41=A
+42=B
+43=C
+44=D
+45=E
+46=F
+47=G
+48=H
+49=I
+4A=J
+4B=K
+4C=L
+4D=M
+4E=N
+4F=O
+50=P
+51=Q
+52=R
+53=S
+54=T
+55=U
+56=V
+57=W
+58=X
+59=Y
+5A=Z
+5B=[
+5C=\
+5D=]
+5E=^
+5F=_
+60=`
+61=a
+62=b
+63=c
+64=d
+65=e
+66=f
+67=g
+68=h
+69=i
+6A=j
+6B=k
+6C=l
+6D=m
+6E=n
+6F=o
+70=p
+71=q
+72=r
+73=s
+74=t
+75=u
+76=v
+77=w
+78=x
+79=y
+7A=z
+7B={
+7C=|
+7D=}
+7E=~
+7F=⌂
+80=А
+81=Б
+82=В
+83=Г
+84=Д
+85=Е
+86=Ж
+87=З
+88=И
+89=Й
+8A=К
+8B=Л
+8C=М
+8D=Н
+8E=О
+8F=П
+90=Р
+91=С
+92=Т
+93=У
+94=Ф
+95=Х
+96=Ц
+97=Ч
+98=Ш
+99=Щ
+9A=Ъ
+9B=Ы
+9C=Ь
+9D=Э
+9E=Ю
+9F=Я
+A0=а
+A1=б
+A2=в
+A3=г
+A4=д
+A5=е
+A6=ж
+A7=з
+A8=и
+A9=й
+AA=к
+AB=л
+AC=м
+AD=н
+AE=о
+AF=п
+B0=░
+B1=▒
+B2=▓
+B3=│
+B4=┤
+B5=╡
+B6=╢
+B7=╖
+B8=╕
+B9=╣
+BA=║
+BB=╗
+BC=╝
+BD=╜
+BE=╛
+BF=┐
+C0=└
+C1=┴
+C2=┬
+C3=├
+C4=─
+C5=┼
+C6=╞
+C7=╟
+C8=╚
+C9=╔
+CA=╩
+CB=╦
+CC=╠
+CD=═
+CE=╬
+CF=╧
+D0=╨
+D1=╤
+D2=╥
+D3=╙
+D4=╘
+D5=╒
+D6=╓
+D7=╫
+D8=╪
+D9=┘
+DA=┌
+DB=█
+DC=▄
+DD=▌
+DE=▐
+DF=▀
+E0=р
+E1=с
+E2=т
+E3=у
+E4=ф
+E5=х
+E6=ц
+E7=ч
+E8=ш
+E9=щ
+EA=ъ
+EB=ы
+EC=ь
+ED=э
+EE=ю
+EF=я
+F0=Ё
+F1=ё
+F2=Є
+F3=є
+F4=Ї
+F5=ї
+F6=Ў
+F7=ў
+F8=°
+F9=∙
+FA=·
+FB=√
+FC=№
+FD=¤
+FE=■
+FF= 

encodings/cyrillic_iso.tbl

@@ -0,0 +1,256 @@
+00=NUL
+01=SOH
+02=STX
+03=ETX
+04=EOT
+05=ENQ
+06=ACK
+07=BEL
+08=BS
+09=TAB
+0A=LF
+0B=VT
+0C=FF
+0D=CR
+0E=SO
+0F=SI
+10=DLE
+11=DC1
+12=DC2
+13=DC3
+14=DC4
+15=NAK
+16=SYN
+17=ETB
+18=CAN
+19=EM
+1A=SUB
+1B=ESC
+1C=FS
+1D=GS
+1E=RS
+1F=US
+20= 
+21=!
+22="
+23=#
+24=$
+25=%
+26=&
+27='
+28=(
+29=)
+2A=*
+2B=+
+2C=,
+2D=-
+2E=.
+2F=/
+30=0
+31=1
+32=2
+33=3
+34=4
+35=5
+36=6
+37=7
+38=8
+39=9
+3A=:
+3B=;
+3C=<
+3D==
+3E=>
+3F=?
+40=@
+41=A
+42=B
+43=C
+44=D
+45=E
+46=F
+47=G
+48=H
+49=I
+4A=J
+4B=K
+4C=L
+4D=M
+4E=N
+4F=O
+50=P
+51=Q
+52=R
+53=S
+54=T
+55=U
+56=V
+57=W
+58=X
+59=Y
+5A=Z
+5B=[
+5C=\
+5D=]
+5E=^
+5F=_
+60=`
+61=a
+62=b
+63=c
+64=d
+65=e
+66=f
+67=g
+68=h
+69=i
+6A=j
+6B=k
+6C=l
+6D=m
+6E=n
+6F=o
+70=p
+71=q
+72=r
+73=s
+74=t
+75=u
+76=v
+77=w
+78=x
+79=y
+7A=z
+7B={
+7C=|
+7D=}
+7E=~
+7F=DEL
+80=€
+81=
+82=‚
+83=ƒ
+84=„
+85=…
+86=†
+87=‡
+88=ˆ
+89=‰
+8A=Š
+8B=‹
+8C=Œ
+8D=
+8E=Ž
+8F=
+90=
+91=‘
+92=’
+93=“
+94=”
+95=•
+96=–
+97=—
+98=˜
+99=™
+9A=š
+9B=›
+9C=œ
+9D=
+9E=ž
+9F=Ÿ
+A0= 
+A1=Ё
+A2=Ђ
+A3=Ѓ
+A4=Є
+A5=Ѕ
+A6=І
+A7=Ї
+A8=Ј
+A9=Љ
+AA=Њ
+AB=Ћ
+AC=Ќ
+AD=­
+AE=Ў
+AF=Џ
+B0=А
+B1=Б
+B2=В
+B3=Г
+B4=Д
+B5=Е
+B6=Ж
+B7=З
+B8=И
+B9=Й
+BA=К
+BB=Л
+BC=М
+BD=Н
+BE=О
+BF=П
+C0=Р
+C1=С
+C2=Т
+C3=У
+C4=Ф
+C5=Х
+C6=Ц
+C7=Ч
+C8=Ш
+C9=Щ
+CA=Ъ
+CB=Ы
+CC=Ь
+CD=Э
+CE=Ю
+CF=Я
+D0=а
+D1=б
+D2=в
+D3=г
+D4=д
+D5=е
+D6=ж
+D7=з
+D8=и
+D9=й
+DA=к
+DB=л
+DC=м
+DD=н
+DE=о
+DF=п
+E0=р
+E1=с
+E2=т
+E3=у
+E4=ф
+E5=х
+E6=ц
+E7=ч
+E8=ш
+E9=щ
+EA=ъ
+EB=ы
+EC=ь
+ED=э
+EE=ю
+EF=я
+F0=№
+F1=ё
+F2=ђ
+F3=ѓ
+F4=є
+F5=ѕ
+F6=і
+F7=ї
+F8=ј
+F9=љ
+FA=њ
+FB=ћ
+FC=ќ
+FD=§
+FE=ў
+FF=џ

encodings/cyrillic_koi8_r.tbl

@@ -0,0 +1,256 @@
+00=NUL
+01=SOH
+02=STX
+03=ETX
+04=EOT
+05=ENQ
+06=ACK
+07=BEL
+08=BS
+09=TAB
+0A=LF
+0B=VT
+0C=FF
+0D=CR
+0E=SO
+0F=SI
+10=DLE
+11=DC1
+12=DC2
+13=DC3
+14=DC4
+15=NAK
+16=SYN
+17=ETB
+18=CAN
+19=EM
+1A=SUB
+1B=ESC
+1C=FS
+1D=GS
+1E=RS
+1F=US
+20= 
+21=!
+22="
+23=#
+24=$
+25=%
+26=&
+27='
+28=(
+29=)
+2A=*
+2B=+
+2C=,
+2D=-
+2E=.
+2F=/
+30=0
+31=1
+32=2
+33=3
+34=4
+35=5
+36=6
+37=7
+38=8
+39=9
+3A=:
+3B=;
+3C=<
+3D==
+3E=>
+3F=?
+40=@
+41=A
+42=B
+43=C
+44=D
+45=E
+46=F
+47=G
+48=H
+49=I
+4A=J
+4B=K
+4C=L
+4D=M
+4E=N
+4F=O
+50=P
+51=Q
+52=R
+53=S
+54=T
+55=U
+56=V
+57=W
+58=X
+59=Y
+5A=Z
+5B=[
+5C=\
+5D=]
+5E=^
+5F=_
+60=`
+61=a
+62=b
+63=c
+64=d
+65=e
+66=f
+67=g
+68=h
+69=i
+6A=j
+6B=k
+6C=l
+6D=m
+6E=n
+6F=o
+70=p
+71=q
+72=r
+73=s
+74=t
+75=u
+76=v
+77=w
+78=x
+79=y
+7A=z
+7B={
+7C=|
+7D=}
+7E=~
+7F=DEL
+80=─
+81=│
+82=┌
+83=┐
+84=└
+85=┘
+86=├
+87=┤
+88=┬
+89=┴
+8A=┼
+8B=▀
+8C=▄
+8D=█
+8E=▌
+8F=▐
+90=░
+91=▒
+92=▓
+93=⌠
+94=■
+95=∙
+96=√
+97=≈
+98=≤
+99=≥
+9A= 
+9B=⌡
+9C=°
+9D=²
+9E=·
+9F=÷
+A0=═
+A1=║
+A2=╒
+A3=ё
+A4=╓
+A5=╔
+A6=╕
+A7=╖
+A8=╗
+A9=╘
+AA=╙
+AB=╚
+AC=╛
+AD=╜
+AE=╝
+AF=╞
+B0=╟
+B1=╠
+B2=╡
+B3=Ё
+B4=╢
+B5=╣
+B6=╤
+B7=╥
+B8=╦
+B9=╧
+BA=╨
+BB=╩
+BC=╪
+BD=╫
+BE=╬
+BF=©
+C0=ю
+C1=а
+C2=б
+C3=ц
+C4=д
+C5=е
+C6=ф
+C7=г
+C8=х
+C9=и
+CA=й
+CB=к
+CC=л
+CD=м
+CE=н
+CF=о
+D0=п
+D1=я
+D2=р
+D3=с
+D4=т
+D5=у
+D6=ж
+D7=в
+D8=ь
+D9=ы
+DA=з
+DB=ш
+DC=э
+DD=щ
+DE=ч
+DF=ъ
+E0=Ю
+E1=А
+E2=Б
+E3=Ц
+E4=Д
+E5=Е
+E6=Ф
+E7=Г
+E8=Х
+E9=И
+EA=Й
+EB=К
+EC=Л
+ED=М
+EE=Н
+EF=О
+F0=П
+F1=Я
+F2=Р
+F3=С
+F4=Т
+F5=У
+F6=Ж
+F7=В
+F8=Ь
+F9=Ы
+FA=З
+FB=Ш
+FC=Э
+FD=Щ
+FE=Ч
+FF=Ъ

encodings/cyrillic_koi8_u.tbl

@@ -0,0 +1,256 @@
+00=NUL
+01=SOH
+02=STX
+03=ETX
+04=EOT
+05=ENQ
+06=ACK
+07=BEL
+08=BS
+09=TAB
+0A=LF
+0B=VT
+0C=FF
+0D=CR
+0E=SO
+0F=SI
+10=DLE
+11=DC1
+12=DC2
+13=DC3
+14=DC4
+15=NAK
+16=SYN
+17=ETB
+18=CAN
+19=EM
+1A=SUB
+1B=ESC
+1C=FS
+1D=GS
+1E=RS
+1F=US
+20= 
+21=!
+22="
+23=#
+24=$
+25=%
+26=&
+27='
+28=(
+29=)
+2A=*
+2B=+
+2C=,
+2D=-
+2E=.
+2F=/
+30=0
+31=1
+32=2
+33=3
+34=4
+35=5
+36=6
+37=7
+38=8
+39=9
+3A=:
+3B=;
+3C=<
+3D==
+3E=>
+3F=?
+40=@
+41=A
+42=B
+43=C
+44=D
+45=E
+46=F
+47=G
+48=H
+49=I
+4A=J
+4B=K
+4C=L
+4D=M
+4E=N
+4F=O
+50=P
+51=Q
+52=R
+53=S
+54=T
+55=U
+56=V
+57=W
+58=X
+59=Y
+5A=Z
+5B=[
+5C=\
+5D=]
+5E=^
+5F=_
+60=`
+61=a
+62=b
+63=c
+64=d
+65=e
+66=f
+67=g
+68=h
+69=i
+6A=j
+6B=k
+6C=l
+6D=m
+6E=n
+6F=o
+70=p
+71=q
+72=r
+73=s
+74=t
+75=u
+76=v
+77=w
+78=x
+79=y
+7A=z
+7B={
+7C=|
+7D=}
+7E=~
+7F=DEL
+80=─
+81=│
+82=┌
+83=┐
+84=└
+85=┘
+86=├
+87=┤
+88=┬
+89=┴
+8A=┼
+8B=▀
+8C=▄
+8D=█
+8E=▌
+8F=▐
+90=░
+91=▒
+92=▓
+93=⌠
+94=■
+95=∙
+96=√
+97=≈
+98=≤
+99=≥
+9A= 
+9B=⌡
+9C=°
+9D=²
+9E=·
+9F=÷
+A0=═
+A1=║
+A2=╒
+A3=ё
+A4=є
+A5=╔
+A6=і
+A7=ї
+A8=╗
+A9=╘
+AA=╙
+AB=╚
+AC=╛
+AD=ґ
+AE=╝
+AF=╞
+B0=╟
+B1=╠
+B2=╡
+B3=Ё
+B4=Є
+B5=╣
+B6=І
+B7=Ї
+B8=╦
+B9=╧
+BA=╨
+BB=╩
+BC=╪
+BD=Ґ
+BE=╬
+BF=©
+C0=ю
+C1=а
+C2=б
+C3=ц
+C4=д
+C5=е
+C6=ф
+C7=г
+C8=х
+C9=и
+CA=й
+CB=к
+CC=л
+CD=м
+CE=н
+CF=о
+D0=п
+D1=я
+D2=р
+D3=с
+D4=т
+D5=у
+D6=ж
+D7=в
+D8=ь
+D9=ы
+DA=з
+DB=ш
+DC=э
+DD=щ
+DE=ч
+DF=ъ
+E0=Ю
+E1=А
+E2=Б
+E3=Ц
+E4=Д
+E5=Е
+E6=Ф
+E7=Г
+E8=Х
+E9=И
+EA=Й
+EB=К
+EC=Л
+ED=М
+EE=Н
+EF=О
+F0=П
+F1=Я
+F2=Р
+F3=С
+F4=Т
+F5=У
+F6=Ж
+F7=В
+F8=Ь
+F9=Ы
+FA=З
+FB=Ш
+FC=Э
+FD=Щ
+FE=Ч
+FF=Ъ

encodings/cyrillic_windows.tbl

@@ -0,0 +1,256 @@
+00=NUL
+01=SOH
+02=STX
+03=ETX
+04=EOT
+05=ENQ
+06=ACK
+07=BEL
+08=BS
+09=TAB
+0A=LF
+0B=VT
+0C=FF
+0D=CR
+0E=SO
+0F=SI
+10=DLE
+11=DC1
+12=DC2
+13=DC3
+14=DC4
+15=NAK
+16=SYN
+17=ETB
+18=CAN
+19=EM
+1A=SUB
+1B=ESC
+1C=FS
+1D=GS
+1E=RS
+1F=US
+20= 
+21=!
+22="
+23=#
+24=$
+25=%
+26=&
+27='
+28=(
+29=)
+2A=*
+2B=+
+2C=,
+2D=-
+2E=.
+2F=/
+30=0
+31=1
+32=2
+33=3
+34=4
+35=5
+36=6
+37=7
+38=8
+39=9
+3A=:
+3B=;
+3C=<
+3D==
+3E=>
+3F=?
+40=@
+41=A
+42=B
+43=C
+44=D
+45=E
+46=F
+47=G
+48=H
+49=I
+4A=J
+4B=K
+4C=L
+4D=M
+4E=N
+4F=O
+50=P
+51=Q
+52=R
+53=S
+54=T
+55=U
+56=V
+57=W
+58=X
+59=Y
+5A=Z
+5B=[
+5C=\
+5D=]
+5E=^
+5F=_
+60=`
+61=a
+62=b
+63=c
+64=d
+65=e
+66=f
+67=g
+68=h
+69=i
+6A=j
+6B=k
+6C=l
+6D=m
+6E=n
+6F=o
+70=p
+71=q
+72=r
+73=s
+74=t
+75=u
+76=v
+77=w
+78=x
+79=y
+7A=z
+7B={
+7C=|
+7D=}
+7E=~
+7F=DEL
+80=Ђ
+81=Ѓ
+82=‚
+83=ѓ
+84=„
+85=…
+86=†
+87=‡
+88=€
+89=‰
+8A=Љ
+8B=‹
+8C=Њ
+8D=Ќ
+8E=Ћ
+8F=Џ
+90=ђ
+91=‘
+92=’
+93=“
+94=”
+95=•
+96=–
+97=—
+98
+99=™
+9A=љ
+9B=›
+9C=њ
+9D=ќ
+9E=ћ
+9F=џ
+A0= 
+A1=Ў
+A2=ў
+A3=Ј
+A4=¤
+A5=Ґ
+A6=¦
+A7=§
+A8=Ё
+A9=©
+AA=Є
+AB=«
+AC=¬
+AD=­
+AE=®
+AF=Ї
+B0=°
+B1=±
+B2=І
+B3=і
+B4=ґ
+B5=µ
+B6=¶
+B7=·
+B8=ё
+B9=№
+BA=є
+BB=»
+BC=ј
+BD=Ѕ
+BE=ѕ
+BF=ї
+C0=А
+C1=Б
+C2=В
+C3=Г
+C4=Д
+C5=Е
+C6=Ж
+C7=З
+C8=И
+C9=Й
+CA=К
+CB=Л
+CC=М
+CD=Н
+CE=О
+CF=П
+D0=Р
+D1=С
+D2=Т
+D3=У
+D4=Ф
+D5=Х
+D6=Ц
+D7=Ч
+D8=Ш
+D9=Щ
+DA=Ъ
+DB=Ы
+DC=Ь
+DD=Э
+DE=Ю
+DF=Я
+E0=а
+E1=б
+E2=в
+E3=г
+E4=д
+E5=е
+E6=ж
+E7=з
+E8=и
+E9=й
+EA=к
+EB=л
+EC=м
+ED=н
+EE=о
+EF=п
+F0=р
+F1=с
+F2=т
+F3=у
+F4=ф
+F5=х
+F6=ц
+F7=ч
+F8=ш
+F9=щ
+FA=ъ
+FB=ы
+FC=ь
+FD=э
+FE=ю
+FF=я

encodings/eastern_europe_iso.tbl

@@ -0,0 +1,256 @@
+00=NUL
+01=SOH
+02=STX
+03=ETX
+04=EOT
+05=ENQ
+06=ACK
+07=BEL
+08=BS
+09=TAB
+0A=LF
+0B=VT
+0C=FF
+0D=CR
+0E=SO
+0F=SI
+10=DLE
+11=DC1
+12=DC2
+13=DC3
+14=DC4
+15=NAK
+16=SYN
+17=ETB
+18=CAN
+19=EM
+1A=SUB
+1B=ESC
+1C=FS
+1D=GS
+1E=RS
+1F=US
+20= 
+21=!
+22="
+23=#
+24=$
+25=%
+26=&
+27='
+28=(
+29=)
+2A=*
+2B=+
+2C=,
+2D=-
+2E=.
+2F=/
+30=0
+31=1
+32=2
+33=3
+34=4
+35=5
+36=6
+37=7
+38=8
+39=9
+3A=:
+3B=;
+3C=<
+3D==
+3E=>
+3F=?
+40=@
+41=A
+42=B
+43=C
+44=D
+45=E
+46=F
+47=G
+48=H
+49=I
+4A=J
+4B=K
+4C=L
+4D=M
+4E=N
+4F=O
+50=P
+51=Q
+52=R
+53=S
+54=T
+55=U
+56=V
+57=W
+58=X
+59=Y
+5A=Z
+5B=[
+5C=\
+5D=]
+5E=^
+5F=_
+60=`
+61=a
+62=b
+63=c
+64=d
+65=e
+66=f
+67=g
+68=h
+69=i
+6A=j
+6B=k
+6C=l
+6D=m
+6E=n
+6F=o
+70=p
+71=q
+72=r
+73=s
+74=t
+75=u
+76=v
+77=w
+78=x
+79=y
+7A=z
+7B={
+7C=|
+7D=}
+7E=~
+7F=DEL
+80=€
+81=
+82=‚
+83=ƒ
+84=„
+85=…
+86=†
+87=‡
+88=ˆ
+89=‰
+8A=Š
+8B=‹
+8C=Œ
+8D=
+8E=Ž
+8F=
+90=
+91=‘
+92=’
+93=“
+94=”
+95=•
+96=–
+97=—
+98=˜
+99=™
+9A=š
+9B=›
+9C=œ
+9D=
+9E=ž
+9F=Ÿ
+A0= 
+A1=Ą
+A2=˘
+A3=Ł
+A4=¤
+A5=Ľ
+A6=Ś
+A7=§
+A8=¨
+A9=Š
+AA=Ş
+AB=Ť
+AC=Ź
+AD=­
+AE=Ž
+AF=Ż
+B0=°
+B1=ą
+B2=˛
+B3=ł
+B4=´
+B5=ľ
+B6=ś
+B7=ˇ
+B8=¸
+B9=š
+BA=ş
+BB=ť
+BC=ź
+BD=˝
+BE=ž
+BF=ż
+C0=Ŕ
+C1=Á
+C2=Â
+C3=Ă
+C4=Ä
+C5=Ĺ
+C6=Ć
+C7=Ç
+C8=Č
+C9=É
+CA=Ę
+CB=Ë
+CC=Ě
+CD=Í
+CE=Î
+CF=Ď
+D0=Đ
+D1=Ń
+D2=Ň
+D3=Ó
+D4=Ô
+D5=Ő
+D6=Ö
+D7=×
+D8=Ř
+D9=Ů
+DA=Ú
+DB=Ű
+DC=Ü
+DD=Ý
+DE=Ţ
+DF=ß
+E0=ŕ
+E1=á
+E2=â
+E3=ă
+E4=ä
+E5=ĺ
+E6=ć
+E7=ç
+E8=č
+E9=é
+EA=ę
+EB=ë
+EC=ě
+ED=í
+EE=î
+EF=ď
+F0=đ
+F1=ń
+F2=ň
+F3=ó
+F4=ô
+F5=ő
+F6=ö
+F7=÷
+F8=ř
+F9=ů
+FA=ú
+FB=ű
+FC=ü
+FD=ý
+FE=ţ
+FF=˙

encodings/eastern_europe_windows.tbl

@@ -0,0 +1,256 @@
+00=NUL
+01=SOH
+02=STX
+03=ETX
+04=EOT
+05=ENQ
+06=ACK
+07=BEL
+08=BS
+09=TAB
+0A=LF
+0B=VT
+0C=FF
+0D=CR
+0E=SO
+0F=SI
+10=DLE
+11=DC1
+12=DC2
+13=DC3
+14=DC4
+15=NAK
+16=SYN
+17=ETB
+18=CAN
+19=EM
+1A=SUB
+1B=ESC
+1C=FS
+1D=GS
+1E=RS
+1F=US
+20= 
+21=!
+22="
+23=#
+24=$
+25=%
+26=&
+27='
+28=(
+29=)
+2A=*
+2B=+
+2C=,
+2D=-
+2E=.
+2F=/
+30=0
+31=1
+32=2
+33=3
+34=4
+35=5
+36=6
+37=7
+38=8
+39=9
+3A=:
+3B=;
+3C=<
+3D==
+3E=>
+3F=?
+40=@
+41=A
+42=B
+43=C
+44=D
+45=E
+46=F
+47=G
+48=H
+49=I
+4A=J
+4B=K
+4C=L
+4D=M
+4E=N
+4F=O
+50=P
+51=Q
+52=R
+53=S
+54=T
+55=U
+56=V
+57=W
+58=X
+59=Y
+5A=Z
+5B=[
+5C=\
+5D=]
+5E=^
+5F=_
+60=`
+61=a
+62=b
+63=c
+64=d
+65=e
+66=f
+67=g
+68=h
+69=i
+6A=j
+6B=k
+6C=l
+6D=m
+6E=n
+6F=o
+70=p
+71=q
+72=r
+73=s
+74=t
+75=u
+76=v
+77=w
+78=x
+79=y
+7A=z
+7B={
+7C=|
+7D=}
+7E=~
+7F=DEL
+80=€
+81
+82=‚
+83
+84=„
+85=…
+86=†
+87=‡
+88
+89=‰
+8A=Š
+8B=‹
+8C=Ś
+8D=Ť
+8E=Ž
+8F=Ź
+90
+91=‘
+92=’
+93=“
+94=”
+95=•
+96=–
+97=—
+98
+99=™
+9A=š
+9B=›
+9C=ś
+9D=ť
+9E=ž
+9F=ź
+A0= 
+A1=ˇ
+A2=˘
+A3=Ł
+A4=¤
+A5=Ą
+A6=¦
+A7=§
+A8=¨
+A9=©
+AA=Ş
+AB=«
+AC=¬
+AD=­
+AE=®
+AF=Ż
+B0=°
+B1=±
+B2=˛
+B3=ł
+B4=´
+B5=µ
+B6=¶
+B7=·
+B8=¸
+B9=ą
+BA=ş
+BB=»
+BC=Ľ
+BD=˝
+BE=ľ
+BF=ż
+C0=Ŕ
+C1=Á
+C2=Â
+C3=Ă
+C4=Ä
+C5=Ĺ
+C6=Ć
+C7=Ç
+C8=Č
+C9=É
+CA=Ę
+CB=Ë
+CC=Ě
+CD=Í
+CE=Î
+CF=Ď
+D0=Đ
+D1=Ń
+D2=Ň
+D3=Ó
+D4=Ô
+D5=Ő
+D6=Ö
+D7=×
+D8=Ř
+D9=Ů
+DA=Ú
+DB=Ű
+DC=Ü
+DD=Ý
+DE=Ţ
+DF=ß
+E0=ŕ
+E1=á
+E2=â
+E3=ă
+E4=ä
+E5=ĺ
+E6=ć
+E7=ç
+E8=č
+E9=é
+EA=ę
+EB=ë
+EC=ě
+ED=í
+EE=î
+EF=ď
+F0=đ
+F1=ń
+F2=ň
+F3=ó
+F4=ô
+F5=ő
+F6=ö
+F7=÷
+F8=ř
+F9=ů
+FA=ú
+FB=ű
+FC=ü
+FD=ý
+FE=ţ
+FF=˙

encodings/ebcdic.tbl

@@ -0,0 +1,256 @@
+00=NUL
+01=SOH
+02=STX
+03=ETX
+04=œ
+05=TAB
+06=†
+07=DEL
+08=—
+09=
+0A=Ž
+0B=VT
+0C=FF
+0D=CR
+0E=SO
+0F=SI
+10=DLE
+11=DC1
+12=DC2
+13=DC3
+14=
+15=…
+16=BS
+17=‡
+18=CAN
+19=EM
+1A=’
+1B=
+1C=FS
+1D=GS
+1E=RS
+1F=US
+20=€
+21=
+22=‚
+23=ƒ
+24=„
+25=LF
+26=ETB
+27=ESC
+28=ˆ
+29=‰
+2A=Š
+2B=‹
+2C=Œ
+2D=ENQ
+2E=ACK
+2F=BEL
+30=
+31=‘
+32=SYN
+33=“
+34=”
+35=•
+36=–
+37=EOT
+38=˜
+39=™
+3A=š
+3B=›
+3C=DC4
+3D=NAK
+3E=ž
+3F=SUB
+40= 
+41= 
+42=â
+43=ä
+44=à
+45=á
+46=ã
+47=å
+48=ç
+49=ñ
+4A=¢
+4B=.
+4C=<
+4D=(
+4E=+
+4F=|
+50=&
+51=é
+52=ê
+53=ë
+54=è
+55=í
+56=î
+57=ï
+58=ì
+59=ß
+5A=!
+5B=$
+5C=*
+5D=)
+5E=;
+5F=¬
+60=-
+61=/
+62=Â
+63=Ä
+64=À
+65=Á
+66=Ã
+67=Å
+68=Ç
+69=Ñ
+6A=¦
+6B=,
+6C=%
+6D=_
+6E=>
+6F=?
+70=ø
+71=É
+72=Ê
+73=Ë
+74=È
+75=Í
+76=Î
+77=Ï
+78=Ì
+79=`
+7A=:
+7B=#
+7C=@
+7D='
+7E==
+7F="
+80=Ø
+81=a
+82=b
+83=c
+84=d
+85=e
+86=f
+87=g
+88=h
+89=i
+8A=«
+8B=»
+8C=ð
+8D=ý
+8E=þ
+8F=±
+90=°
+91=j
+92=k
+93=l
+94=m
+95=n
+96=o
+97=p
+98=q
+99=r
+9A=ª
+9B=º
+9C=æ
+9D=¸
+9E=Æ
+9F=¤
+A0=µ
+A1=~
+A2=s
+A3=t
+A4=u
+A5=v
+A6=w
+A7=x
+A8=y
+A9=z
+AA=¡
+AB=¿
+AC=Ð
+AD=Ý
+AE=Þ
+AF=®
+B0=^
+B1=£
+B2=¥
+B3=·
+B4=©
+B5=§
+B6=¶
+B7=¼
+B8=½
+B9=¾
+BA=[
+BB=]
+BC=¯
+BD=¨
+BE=´
+BF=×
+C0={
+C1=A
+C2=B
+C3=C
+C4=D
+C5=E
+C6=F
+C7=G
+C8=H
+C9=I
+CA=­
+CB=ô
+CC=ö
+CD=ò
+CE=ó
+CF=õ
+D0=}
+D1=J
+D2=K
+D3=L
+D4=M
+D5=N
+D6=O
+D7=P
+D8=Q
+D9=R
+DA=¹
+DB=û
+DC=ü
+DD=ù
+DE=ú
+DF=ÿ
+E0=\
+E1=÷
+E2=S
+E3=T
+E4=U
+E5=V
+E6=W
+E7=X
+E8=Y
+E9=Z
+EA=²
+EB=Ô
+EC=Ö
+ED=Ò
+EE=Ó
+EF=Õ
+F0=0
+F1=1
+F2=2
+F3=3
+F4=4
+F5=5
+F6=6
+F7=7
+F8=8
+F9=9
+FA=³
+FB=Û
+FC=Ü
+FD=Ù
+FE=Ú
+FF=Ÿ

encodings/greek_iso.tbl

@@ -0,0 +1,256 @@
+00=NUL
+01=SOH
+02=STX
+03=ETX
+04=EOT
+05=ENQ
+06=ACK
+07=BEL
+08=BS
+09=TAB
+0A=LF
+0B=VT
+0C=FF
+0D=CR
+0E=SO
+0F=SI
+10=DLE
+11=DC1
+12=DC2
+13=DC3
+14=DC4
+15=NAK
+16=SYN
+17=ETB
+18=CAN
+19=EM
+1A=SUB
+1B=ESC
+1C=FS
+1D=GS
+1E=RS
+1F=US
+20= 
+21=!
+22="
+23=#
+24=$
+25=%
+26=&
+27='
+28=(
+29=)
+2A=*
+2B=+
+2C=,
+2D=-
+2E=.
+2F=/
+30=0
+31=1
+32=2
+33=3
+34=4
+35=5
+36=6
+37=7
+38=8
+39=9
+3A=:
+3B=;
+3C=<
+3D==
+3E=>
+3F=?
+40=@
+41=A
+42=B
+43=C
+44=D
+45=E
+46=F
+47=G
+48=H
+49=I
+4A=J
+4B=K
+4C=L
+4D=M
+4E=N
+4F=O
+50=P
+51=Q
+52=R
+53=S
+54=T
+55=U
+56=V
+57=W
+58=X
+59=Y
+5A=Z
+5B=[
+5C=\
+5D=]
+5E=^
+5F=_
+60=`
+61=a
+62=b
+63=c
+64=d
+65=e
+66=f
+67=g
+68=h
+69=i
+6A=j
+6B=k
+6C=l
+6D=m
+6E=n
+6F=o
+70=p
+71=q
+72=r
+73=s
+74=t
+75=u
+76=v
+77=w
+78=x
+79=y
+7A=z
+7B={
+7C=|
+7D=}
+7E=~
+7F=DEL
+80=€
+81=
+82=‚
+83=ƒ
+84=„
+85=…
+86=†
+87=‡
+88=ˆ
+89=‰
+8A=Š
+8B=‹
+8C=Œ
+8D=
+8E=Ž
+8F=
+90=
+91=‘
+92=’
+93=“
+94=”
+95=•
+96=–
+97=—
+98=˜
+99=™
+9A=š
+9B=›
+9C=œ
+9D=
+9E=ž
+9F=Ÿ
+A0= 
+A1=‘
+A2=’
+A3=£
+A4
+A5
+A6=¦
+A7=§
+A8=¨
+A9=©
+AA
+AB=«
+AC=¬
+AD=­
+AE
+AF=―
+B0=°
+B1=±
+B2=²
+B3=³
+B4=΄
+B5=΅
+B6=Ά
+B7=·
+B8=Έ
+B9=Ή
+BA=Ί
+BB=»
+BC=Ό
+BD=½
+BE=Ύ
+BF=Ώ
+C0=ΐ
+C1=Α
+C2=Β
+C3=Γ
+C4=Δ
+C5=Ε
+C6=Ζ
+C7=Η
+C8=Θ
+C9=Ι
+CA=Κ
+CB=Λ
+CC=Μ
+CD=Ν
+CE=Ξ
+CF=Ο
+D0=Π
+D1=Ρ
+D2
+D3=Σ
+D4=Τ
+D5=Υ
+D6=Φ
+D7=Χ
+D8=Ψ
+D9=Ω
+DA=Ϊ
+DB=Ϋ
+DC=ά
+DD=έ
+DE=ή
+DF=ί
+E0=ΰ
+E1=α
+E2=β
+E3=γ
+E4=δ
+E5=ε
+E6=ζ
+E7=η
+E8=θ
+E9=ι
+EA=κ
+EB=λ
+EC=μ
+ED=ν
+EE=ξ
+EF=ο
+F0=π
+F1=ρ
+F2=ς
+F3=σ
+F4=τ
+F5=υ
+F6=φ
+F7=χ
+F8=ψ
+F9=ω
+FA=ϊ
+FB=ϋ
+FC=ό
+FD=ύ
+FE=ώ
+FF

encodings/greek_windows.tbl

@@ -0,0 +1,256 @@
+00=NUL
+01=SOH
+02=STX
+03=ETX
+04=EOT
+05=ENQ
+06=ACK
+07=BEL
+08=BS
+09=TAB
+0A=LF
+0B=VT
+0C=FF
+0D=CR
+0E=SO
+0F=SI
+10=DLE
+11=DC1
+12=DC2
+13=DC3
+14=DC4
+15=NAK
+16=SYN
+17=ETB
+18=CAN
+19=EM
+1A=SUB
+1B=ESC
+1C=FS
+1D=GS
+1E=RS
+1F=US
+20= 
+21=!
+22="
+23=#
+24=$
+25=%
+26=&
+27='
+28=(
+29=)
+2A=*
+2B=+
+2C=,
+2D=-
+2E=.
+2F=/
+30=0
+31=1
+32=2
+33=3
+34=4
+35=5
+36=6
+37=7
+38=8
+39=9
+3A=:
+3B=;
+3C=<
+3D==
+3E=>
+3F=?
+40=@
+41=A
+42=B
+43=C
+44=D
+45=E
+46=F
+47=G
+48=H
+49=I
+4A=J
+4B=K
+4C=L
+4D=M
+4E=N
+4F=O
+50=P
+51=Q
+52=R
+53=S
+54=T
+55=U
+56=V
+57=W
+58=X
+59=Y
+5A=Z
+5B=[
+5C=\
+5D=]
+5E=^
+5F=_
+60=`
+61=a
+62=b
+63=c
+64=d
+65=e
+66=f
+67=g
+68=h
+69=i
+6A=j
+6B=k
+6C=l
+6D=m
+6E=n
+6F=o
+70=p
+71=q
+72=r
+73=s
+74=t
+75=u
+76=v
+77=w
+78=x
+79=y
+7A=z
+7B={
+7C=|
+7D=}
+7E=~
+7F=DEL
+80=€
+81
+82=‚
+83=ƒ
+84=„
+85=…
+86=†
+87=‡
+88
+89=‰
+8A
+8B=‹
+8C
+8D
+8E
+8F
+90
+91=‘
+92=’
+93=“
+94=”
+95=•
+96=–
+97=—
+98
+99=™
+9A
+9B=›
+9C
+9D
+9E
+9F
+A0= 
+A1=΅
+A2=Ά
+A3=£
+A4=¤
+A5=¥
+A6=¦
+A7=§
+A8=¨
+A9=©
+AA
+AB=«
+AC=¬
+AD=­
+AE=®
+AF=―
+B0=°
+B1=±
+B2=²
+B3=³
+B4=΄
+B5=µ
+B6=¶
+B7=·
+B8=Έ
+B9=Ή
+BA=Ί
+BB=»
+BC=Ό
+BD=½
+BE=Ύ
+BF=Ώ
+C0=ΐ
+C1=Α
+C2=Β
+C3=Γ
+C4=Δ
+C5=Ε
+C6=Ζ
+C7=Η
+C8=Θ
+C9=Ι
+CA=Κ
+CB=Λ
+CC=Μ
+CD=Ν
+CE=Ξ
+CF=Ο
+D0=Π
+D1=Ρ
+D2
+D3=Σ
+D4=Τ
+D5=Υ
+D6=Φ
+D7=Χ
+D8=Ψ
+D9=Ω
+DA=Ϊ
+DB=Ϋ
+DC=ά
+DD=έ
+DE=ή
+DF=ί
+E0=ΰ
+E1=α
+E2=β
+E3=γ
+E4=δ
+E5=ε
+E6=ζ
+E7=η
+E8=θ
+E9=ι
+EA=κ
+EB=λ
+EC=μ
+ED=ν
+EE=ξ
+EF=ο
+F0=π
+F1=ρ
+F2=ς
+F3=σ
+F4=τ
+F5=υ
+F6=φ
+F7=χ
+F8=ψ
+F9=ω
+FA=ϊ
+FB=ϋ
+FC=ό
+FD=ύ
+FE=ώ
+FF

encodings/hebrew_iso.tbl

@@ -0,0 +1,256 @@
+00=NUL
+01=SOH
+02=STX
+03=ETX
+04=EOT
+05=ENQ
+06=ACK
+07=BEL
+08=BS
+09=TAB
+0A=LF
+0B=VT
+0C=FF
+0D=CR
+0E=SO
+0F=SI
+10=DLE
+11=DC1
+12=DC2
+13=DC3
+14=DC4
+15=NAK
+16=SYN
+17=ETB
+18=CAN
+19=EM
+1A=SUB
+1B=ESC
+1C=FS
+1D=GS
+1E=RS
+1F=US
+20= 
+21=!
+22="
+23=#
+24=$
+25=%
+26=&
+27='
+28=(
+29=)
+2A=*
+2B=+
+2C=,
+2D=-
+2E=.
+2F=/
+30=0
+31=1
+32=2
+33=3
+34=4
+35=5
+36=6
+37=7
+38=8
+39=9
+3A=:
+3B=;
+3C=<
+3D==
+3E=>
+3F=?
+40=@
+41=A
+42=B
+43=C
+44=D
+45=E
+46=F
+47=G
+48=H
+49=I
+4A=J
+4B=K
+4C=L
+4D=M
+4E=N
+4F=O
+50=P
+51=Q
+52=R
+53=S
+54=T
+55=U
+56=V
+57=W
+58=X
+59=Y
+5A=Z
+5B=[
+5C=\
+5D=]
+5E=^
+5F=_
+60=`
+61=a
+62=b
+63=c
+64=d
+65=e
+66=f
+67=g
+68=h
+69=i
+6A=j
+6B=k
+6C=l
+6D=m
+6E=n
+6F=o
+70=p
+71=q
+72=r
+73=s
+74=t
+75=u
+76=v
+77=w
+78=x
+79=y
+7A=z
+7B={
+7C=|
+7D=}
+7E=~
+7F=DEL
+80=€
+81=
+82=‚
+83=ƒ
+84=„
+85=…
+86=†
+87=‡
+88=ˆ
+89=‰
+8A=Š
+8B=‹
+8C=Œ
+8D=
+8E=Ž
+8F=
+90=
+91=‘
+92=’
+93=“
+94=”
+95=•
+96=–
+97=—
+98=˜
+99=™
+9A=š
+9B=›
+9C=œ
+9D=
+9E=ž
+9F=Ÿ
+A0= 
+A1
+A2=¢
+A3=£
+A4=¤
+A5=¥
+A6=¦
+A7=§
+A8=¨
+A9=©
+AA=×
+AB=«
+AC=¬
+AD=­
+AE=®
+AF=‾
+B0=°
+B1=±
+B2=²
+B3=³
+B4=´
+B5=µ
+B6=¶
+B7=·
+B8=¸
+B9=¹
+BA=÷
+BB=»
+BC=¼
+BD=½
+BE=¾
+BF
+C0
+C1
+C2
+C3
+C4
+C5
+C6
+C7
+C8
+C9
+CA
+CB
+CC
+CD
+CE
+CF
+D0
+D1
+D2
+D3
+D4
+D5
+D6
+D7
+D8
+D9
+DA
+DB
+DC
+DD
+DE
+DF=‗
+E0=א
+E1=ב
+E2=ג
+E3=ד
+E4=ה
+E5=ו
+E6=ז
+E7=ח
+E8=ט
+E9=י
+EA=ך
+EB=כ
+EC=ל
+ED=ם
+EE=מ
+EF=ן
+F0=נ
+F1=ס
+F2=ע
+F3=ף
+F4=פ
+F5=ץ
+F6=צ
+F7=ק
+F8=ר
+F9=ש
+FA=ת
+FB
+FC
+FD
+FE
+FF

encodings/hebrew_windows.tbl

@@ -0,0 +1,256 @@
+00=NUL
+01=SOH
+02=STX
+03=ETX
+04=EOT
+05=ENQ
+06=ACK
+07=BEL
+08=BS
+09=TAB
+0A=LF
+0B=VT
+0C=FF
+0D=CR
+0E=SO
+0F=SI
+10=DLE
+11=DC1
+12=DC2
+13=DC3
+14=DC4
+15=NAK
+16=SYN
+17=ETB
+18=CAN
+19=EM
+1A=SUB
+1B=ESC
+1C=FS
+1D=GS
+1E=RS
+1F=US
+20= 
+21=!
+22="
+23=#
+24=$
+25=%
+26=&
+27='
+28=(
+29=)
+2A=*
+2B=+
+2C=,
+2D=-
+2E=.
+2F=/
+30=0
+31=1
+32=2
+33=3
+34=4
+35=5
+36=6
+37=7
+38=8
+39=9
+3A=:
+3B=;
+3C=<
+3D==
+3E=>
+3F=?
+40=@
+41=A
+42=B
+43=C
+44=D
+45=E
+46=F
+47=G
+48=H
+49=I
+4A=J
+4B=K
+4C=L
+4D=M
+4E=N
+4F=O
+50=P
+51=Q
+52=R
+53=S
+54=T
+55=U
+56=V
+57=W
+58=X
+59=Y
+5A=Z
+5B=[
+5C=\
+5D=]
+5E=^
+5F=_
+60=`
+61=a
+62=b
+63=c
+64=d
+65=e
+66=f
+67=g
+68=h
+69=i
+6A=j
+6B=k
+6C=l
+6D=m
+6E=n
+6F=o
+70=p
+71=q
+72=r
+73=s
+74=t
+75=u
+76=v
+77=w
+78=x
+79=y
+7A=z
+7B={
+7C=|
+7D=}
+7E=~
+7F=DEL
+80=€
+81
+82=‚
+83=ƒ
+84=„
+85=…
+86=†
+87=‡
+88=ˆ
+89=‰
+8A
+8B=‹
+8C
+8D
+8E
+8F
+90
+91=‘
+92=’
+93=“
+94=”
+95=•
+96=–
+97=—
+98=˜
+99=™
+9A
+9B=›
+9C
+9D
+9E
+9F
+A0= 
+A1=¡
+A2=¢
+A3=£
+A4=₪
+A5=¥
+A6=¦
+A7=§
+A8=¨
+A9=©
+AA=×
+AB=«
+AC=¬
+AD=­
+AE=®
+AF=¯
+B0=°
+B1=±
+B2=²
+B3=³
+B4=´
+B5=µ
+B6=¶
+B7=·
+B8=¸
+B9=¹
+BA=÷
+BB=»
+BC=¼
+BD=½
+BE=¾
+BF=¿
+C0=ְ
+C1=ֱ
+C2=ֲ
+C3=ֳ
+C4=ִ
+C5=ֵ
+C6=ֶ
+C7=ַ
+C8=ָ
+C9=ֹ
+CA
+CB=ֻ
+CC=ּ
+CD=ֽ
+CE=־
+CF=ֿ
+D0=׀
+D1=ׁ
+D2=ׂ
+D3=׃
+D4=װ
+D5=ױ
+D6=ײ
+D7=׳
+D8=״
+D9
+DA
+DB
+DC
+DD
+DE
+DF
+E0=א
+E1=ב
+E2=ג
+E3=ד
+E4=ה
+E5=ו
+E6=ז
+E7=ח
+E8=ט
+E9=י
+EA=ך
+EB=כ
+EC=ל
+ED=ם
+EE=מ
+EF=ן
+F0=נ
+F1=ס
+F2=ע
+F3=ף
+F4=פ
+F5=ץ
+F6=צ
+F7=ק
+F8=ר
+F9=ש
+FA=ת
+FB
+FC
+FD=‎
+FE=‏
+FF

encodings/macintosh.tbl

@@ -0,0 +1,256 @@
+00=NUL
+01=SOH
+02=STX
+03=ETX
+04=EOT
+05=ENQ
+06=ACK
+07=BEL
+08=BS
+09=TAB
+0A=LF
+0B=VT
+0C=FF
+0D=CR
+0E=SO
+0F=SI
+10=DLE
+11=DC1
+12=DC2
+13=DC3
+14=DC4
+15=NAK
+16=SYN
+17=ETB
+18=CAN
+19=EM
+1A=SUB
+1B=ESC
+1C=FS
+1D=GS
+1E=RS
+1F=US
+20= 
+21=!
+22="
+23=#
+24=$
+25=%
+26=&
+27='
+28=(
+29=)
+2A=*
+2B=+
+2C=,
+2D=-
+2E=.
+2F=/
+30=0
+31=1
+32=2
+33=3
+34=4
+35=5
+36=6
+37=7
+38=8
+39=9
+3A=:
+3B=;
+3C=<
+3D==
+3E=>
+3F=?
+40=@
+41=A
+42=B
+43=C
+44=D
+45=E
+46=F
+47=G
+48=H
+49=I
+4A=J
+4B=K
+4C=L
+4D=M
+4E=N
+4F=O
+50=P
+51=Q
+52=R
+53=S
+54=T
+55=U
+56=V
+57=W
+58=X
+59=Y
+5A=Z
+5B=[
+5C=\
+5D=]
+5E=^
+5F=_
+60=`
+61=a
+62=b
+63=c
+64=d
+65=e
+66=f
+67=g
+68=h
+69=i
+6A=j
+6B=k
+6C=l
+6D=m
+6E=n
+6F=o
+70=p
+71=q
+72=r
+73=s
+74=t
+75=u
+76=v
+77=w
+78=x
+79=y
+7A=z
+7B={
+7C=|
+7D=}
+7E=~
+7F=DEL
+80=Ä
+81=Å
+82=Ç
+83=É
+84=Ñ
+85=Ö
+86=Ü
+87=á
+88=à
+89=â
+8A=ä
+8B=ã
+8C=å
+8D=ç
+8E=é
+8F=è
+90=ê
+91=ë
+92=í
+93=ì
+94=î
+95=ï
+96=ñ
+97=ó
+98=ò
+99=ô
+9A=ö
+9B=õ
+9C=ú
+9D=ù
+9E=û
+9F=ü
+A0=†
+A1=°
+A2=¢
+A3=£
+A4=§
+A5=•
+A6=¶
+A7=ß
+A8=®
+A9=©
+AA=™
+AB=´
+AC=¨
+AD=≠
+AE=Æ
+AF=Ø
+B0=∞
+B1=±
+B2=≤
+B3=≥
+B4=¥
+B5=µ
+B6=∂
+B7=∑
+B8=∏
+B9=π
+BA=∫
+BB=ª
+BC=º
+BD=Ω
+BE=æ
+BF=ø
+C0=¿
+C1=¡
+C2=¬
+C3=√
+C4=ƒ
+C5=≈
+C6=∆
+C7=«
+C8=»
+C9=…
+CA= 
+CB=À
+CC=Ã
+CD=Õ
+CE=Œ
+CF=œ
+D0=–
+D1=—
+D2=“
+D3=”
+D4=‘
+D5=’
+D6=÷
+D7=◊
+D8=ÿ
+D9=Ÿ
+DA=⁄
+DB=€
+DC=‹
+DD=›
+DE=fi
+DF=fl
+E0=‡
+E1=·
+E2=‚
+E3=„
+E4=‰
+E5=Â
+E6=Ê
+E7=Á
+E8=Ë
+E9=È
+EA=Í
+EB=Î
+EC=Ï
+ED=Ì
+EE=Ó
+EF=Ô
+F0=
+F1=Ò
+F2=Ú
+F3=Û
+F4=Ù
+F5=ı
+F6=ˆ
+F7=˜
+F8=¯
+F9=˘
+FA=˙
+FB=˚
+FC=¸
+FD=˝
+FE=˛
+FF=ˇ

encodings/pokegen1_en.tbl

@@ -0,0 +1,255 @@
+00=NUL
+01
+02
+03
+04
+05
+06
+07
+08
+09
+0A
+0B
+0C
+0D
+0E
+0F
+11
+12
+13
+14
+15
+16
+17
+18
+19
+1A
+1B
+1C
+1D
+1E
+1F
+20
+21
+22
+23
+24
+25
+26
+27
+28
+29
+2A
+2B
+2C
+2D
+2E
+2F
+30
+31
+32
+33
+34
+35
+36
+37
+38
+39
+3A
+3B
+3C
+3D
+3E
+3F
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49=page
+4A=PkMn
+4B=_cont
+4C=autocont
+4D
+4E=next line
+4F=bottom line
+50=end
+51=paragraph
+52=player name
+53=rival name
+54=Poké
+55=cont
+56=......
+57=done
+58=prompt
+59=target
+5A=user
+5B=PC
+5C=TM
+5D=TRAINER
+5E=ROCKET
+5F=dex
+60=A
+61=B
+62=C
+63=D
+64=E
+65=F
+66=G
+67=H
+68=I
+69=V
+6A=S
+6B=L
+6C=M
+6D=:
+6E=ぃ
+6F=ぅ
+70=‘
+71=’
+72=“
+73=”
+74=・
+75=⋯
+76=ぁ
+77=ぇ
+78=ぉ
+79
+7A
+7B
+7C
+7D
+7E
+7F
+80=A
+81=B
+82=C
+83=D
+84=E
+85=F
+86=G
+87=H
+88=I
+89=J
+8A=K
+8B=L
+8C=M
+8D=N
+8E=O
+8F=P
+90=Q
+91=R
+92=S
+93=T
+94=U
+95=V
+96=W
+97=X
+98=Y
+99=Z
+9A=(
+9B=)
+9C=
+9D=;
+9E=[
+9F=]
+A0=a
+A1=b
+A2=c
+A3=d
+A4=e
+A5=f
+A6=g
+A7=h
+A8=i
+A9=j
+AA=k
+AB=l
+AC=m
+AD=n
+AE=o
+AF=p
+B0=q
+B1=r
+B2=s
+B3=t
+B4=u
+B5=v
+B6=w
+B7=x
+B8=y
+B9=z
+BA=é
+BB='d
+BC='l
+BD='s
+BE='t
+BF='v
+C0
+C1
+C2
+C3
+C4
+C5
+C6
+C7
+C8
+C9
+CA
+CB
+CC
+CD
+CE
+CF
+D0
+D1
+D2
+D3
+D4
+D5
+D6
+D7
+D8
+D9
+DA
+DB
+DC
+DD
+DE
+DF
+E0='
+E1=Pk
+E2=Mn
+E3=-
+E4='r
+E5='m
+E6=?
+E7=!
+E8=.
+E9=ァ
+EA=ゥ
+EB=ェ
+EC=▷
+ED=▶
+EE=▼
+EF=♂
+F0=$
+F1=×
+F2=.
+F3=/
+F4=,
+F5=♀
+F6=0
+F7=1
+F8=2
+F9=3
+FA=4
+FB=5
+FC=6
+FD=7
+FE=8
+FF=9

encodings/pokegen3_en.tbl

@@ -0,0 +1,256 @@
+00
+01=À
+02=Á
+03=Â
+04=Ç
+05=È
+06=È
+07=Ê
+08=Ë
+09=Ì
+0a
+0b=Î
+0c=Ï
+0d=Ò
+0e=Ó
+0f=Ô
+10=Œ
+11=Ù
+12=Ú
+13=Û
+14=Ñ
+15=ß
+16=à
+17=á
+18
+19=ç
+1a=è
+1b=é
+1c=ê
+1d=ë
+1e=ì
+1f
+20=î
+21=ï
+22=ò
+23=ó
+24=ô
+25=œ
+26=ù
+27=ú
+28=û
+29=ñ
+2a=º
+2b=ª
+2c=ᵉʳ
+2d=&
+2e=+
+2f
+30
+31
+32
+33
+34
+35==
+36
+37
+38
+39
+3a
+3b
+3c
+3d
+3e
+3f
+40
+41
+42
+43
+44
+45
+46
+47
+48
+49
+4a
+4b
+4c
+4d
+4e
+4f
+50
+51=¿
+52=¡
+53=Pk
+54=Mn
+55=Po
+56=Ké
+57
+58
+59
+5a=Í
+5b=%
+5c=(
+5d=)
+5e
+5f
+60
+61
+62
+63
+64
+65
+66
+67
+68=â
+69
+6a
+6b
+6c
+6d
+6e
+6f=í
+70
+71
+72
+73
+74
+75
+76
+77
+78
+79=⬆
+7a=⬇
+7b=⬅
+7c=➡
+7d
+7e
+7f
+80
+81
+82
+83
+84
+85
+86
+87
+88
+89
+8a
+8b
+8c
+8d
+8e
+8f
+90
+91
+92
+93
+94
+95
+96
+97
+98
+99
+9a
+9b
+9c
+9d
+9e
+9f
+a0
+a1=0
+a2=1
+a3=2
+a4=3
+a5=4
+a6=5
+a7=6
+a8=7
+a9=8
+aa=9
+ab=!
+ac=?
+ad=.
+ae=-
+af=・
+b0
+b1=“
+b2=”
+b3=‘
+b4=’
+b5=♂
+b6=♀
+b7
+b8=,
+b9=×
+ba=/
+bb=A
+bc=B
+bd=C
+be=D
+bf=E
+c0=F
+c1=G
+c2=H
+c3=I
+c4=J
+c5=K
+c6=L
+c7=M
+c8=N
+c9=O
+ca=P
+cb=Q
+cc=R
+cd=S
+ce=T
+cf=U
+d0=V
+d1=W
+d2=X
+d3=Y
+d4=Z
+d5=a
+d6=b
+d7=c
+d8=d
+d9=e
+da=f
+db=g
+dc=h
+dd=i
+de=j
+df=k
+e0=l
+e1=m
+e2=n
+e3=o
+e4=p
+e5=q
+e6=r
+e7=s
+e8=t
+e9=u
+ea=v
+eb=w
+ec=x
+ed=y
+ee=z
+ef=▶
+f0=:
+f1=Ä
+f2=Ö
+f3=Ü
+f4=ä
+f5=ö
+f6=ü
+f7
+f8
+f9
+fa
+fb
+fc
+fd
+fe
+ff

encodings/shiftjis.tbl

@@ -1,6 +1,3 @@
-00=()
-090D=(R)
-0A=(BR)
 20= 
 21=!
 22="
@@ -124,12 +121,12 @@
 8159=〆
 815A=〇
 815B=ー
-815C=―
+815C=—
 815D=‐
 815E=／
 815F=＼
-8160=～
-8161=∥
+8160=〜
+8161=‖
 8162=｜
 8163=…
 8164=‥
@@ -156,7 +153,7 @@
 8179=【
 817A=】
 817B=＋
-817C=－
+817C=−
 817D=±
 817E=×
 8180=÷
@@ -176,8 +173,8 @@
 818E=℃
 818F=￥
 8190=＄
-8191=￠
-8192=￡
+8191=¢
+8192=£
 8193=％
 8194=＃
 8195=＆
@@ -190,6 +187,7 @@
 819C=●
 819D=◎
 819E=◇
+819F=◆
 81A0=□
 81A1=■
 81A2=△
@@ -213,7 +211,7 @@
 81BF=∩
 81C8=∧
 81C9=∨
-81CA=￢
+81CA=¬
 81CB=⇒
 81CC=⇔
 81CD=∀
@@ -619,89 +617,6 @@
 84BC=┥
 84BD=┸
 84BE=╂
-8740=①
-8741=②
-8742=③
-8743=④
-8744=⑤
-8745=⑥
-8746=⑦
-8747=⑧
-8748=⑨
-8749=⑩
-874A=⑪
-874B=⑫
-874C=⑬
-874D=⑭
-874E=⑮
-874F=⑯
-8750=⑰
-8751=⑱
-8752=⑲
-8753=⑳
-8754=Ⅰ
-8755=Ⅱ
-8756=Ⅲ
-8757=Ⅳ
-8758=Ⅴ
-8759=Ⅵ
-875A=Ⅶ
-875B=Ⅷ
-875C=Ⅸ
-875D=Ⅹ
-875F=㍉
-8760=㌔
-8761=㌢
-8762=㍍
-8763=㌘
-8764=㌧
-8765=㌃
-8766=㌶
-8767=㍑
-8768=㍗
-8769=㌍
-876A=㌦
-876B=㌣
-876C=㌫
-876D=㍊
-876E=㌻
-876F=㎜
-8770=㎝
-8771=㎞
-8772=㎎
-8773=㎏
-8774=㏄
-8775=㎡
-877E=㍻
-8780=〝
-8781=〟
-8782=№
-8783=㏍
-8784=℡
-8785=㊤
-8786=㊥
-8787=㊦
-8788=㊧
-8789=㊨
-878A=㈱
-878B=㈲
-878C=㈹
-878D=㍾
-878E=㍽
-878F=㍼
-8790=≒
-8791=≡
-8792=∫
-8793=∮
-8794=∑
-8795=√
-8796=⊥
-8797=∠
-8798=∟
-8799=⊿
-879A=∵
-879B=∩
-879C=∪
 889F=亜
 88A0=唖
 88A1=娃
@@ -7120,4 +7035,3 @@ EAA1=遙
 EAA2=瑤
 EAA3=凜
 EAA4=熙
-FA5B=∵

encodings/thai.tbl

@@ -0,0 +1,256 @@
+00=NUL
+01=SOH
+02=STX
+03=ETX
+04=EOT
+05=ENQ
+06=ACK
+07=BEL
+08=BS
+09=TAB
+0A=LF
+0B=VT
+0C=FF
+0D=CR
+0E=SO
+0F=SI
+10=DLE
+11=DC1
+12=DC2
+13=DC3
+14=DC4
+15=NAK
+16=SYN
+17=ETB
+18=CAN
+19=EM
+1A=SUB
+1B=ESC
+1C=FS
+1D=GS
+1E=RS
+1F=US
+20= 
+21=!
+22="
+23=#
+24=$
+25=%
+26=&
+27='
+28=(
+29=)
+2A=*
+2B=+
+2C=,
+2D=-
+2E=.
+2F=/
+30=0
+31=1
+32=2
+33=3
+34=4
+35=5
+36=6
+37=7
+38=8
+39=9
+3A=:
+3B=;
+3C=<
+3D==
+3E=>
+3F=?
+40=@
+41=A
+42=B
+43=C
+44=D
+45=E
+46=F
+47=G
+48=H
+49=I
+4A=J
+4B=K
+4C=L
+4D=M
+4E=N
+4F=O
+50=P
+51=Q
+52=R
+53=S
+54=T
+55=U
+56=V
+57=W
+58=X
+59=Y
+5A=Z
+5B=[
+5C=\
+5D=]
+5E=^
+5F=_
+60=`
+61=a
+62=b
+63=c
+64=d
+65=e
+66=f
+67=g
+68=h
+69=i
+6A=j
+6B=k
+6C=l
+6D=m
+6E=n
+6F=o
+70=p
+71=q
+72=r
+73=s
+74=t
+75=u
+76=v
+77=w
+78=x
+79=y
+7A=z
+7B={
+7C=|
+7D=}
+7E=~
+7F=DEL
+80=€
+81
+82
+83
+84
+85=…
+86
+87
+88
+89
+8A
+8B
+8C
+8D
+8E
+8F
+90
+91=‘
+92=’
+93=“
+94=”
+95=•
+96=–
+97=—
+98
+99
+9A
+9B
+9C
+9D
+9E
+9F
+A0
+A1=ก
+A2=ข
+A3=ฃ
+A4=ค
+A5=ฅ
+A6=ฆ
+A7=ง
+A8=จ
+A9=ฉ
+AA=ช
+AB=ซ
+AC=ฌ
+AD=ญ
+AE=ฎ
+AF=ฏ
+B0=ฐ
+B1=ฑ
+B2=ฒ
+B3=ณ
+B4=ด
+B5=ต
+B6=ถ
+B7=ท
+B8=ธ
+B9=น
+BA=บ
+BB=ป
+BC=ผ
+BD=ฝ
+BE=พ
+BF=ฟ
+C0=ภ
+C1=ม
+C2=ย
+C3=ร
+C4=ฤ
+C5=ล
+C6=ฦ
+C7=ว
+C8=ศ
+C9=ษ
+CA=ส
+CB=ห
+CC=ฬ
+CD=อ
+CE=ฮ
+CF=ฯ
+D0=ะ
+D1=ั
+D2=า
+D3=ำ
+D4=ิ
+D5=ี
+D6=ึ
+D7=ื
+D8=ุ
+D9=ู
+DA=ฺ
+DB
+DC
+DD
+DE
+DF=฿
+E0=เ
+E1=แ
+E2=โ
+E3=ใ
+E4=ไ
+E5=ๅ
+E6=ๆ
+E7=็
+E8=่
+E9=้
+EA=๊
+EB=๋
+EC=์
+ED=ํ
+EE=๎
+EF=๏
+F0=๐
+F1=๑
+F2=๒
+F3=๓
+F4=๔
+F5=๕
+F6=๖
+F7=๗
+F8=๘
+F9=๙
+FA=๚
+FB=๛
+FC
+FD
+FE
+FF

encodings/turkish_iso.tbl

@@ -0,0 +1,256 @@
+00=NUL
+01=SOH
+02=STX
+03=ETX
+04=EOT
+05=ENQ
+06=ACK
+07=BEL
+08=BS
+09=TAB
+0A=LF
+0B=VT
+0C=FF
+0D=CR
+0E=SO
+0F=SI
+10=DLE
+11=DC1
+12=DC2
+13=DC3
+14=DC4
+15=NAK
+16=SYN
+17=ETB
+18=CAN
+19=EM
+1A=SUB
+1B=ESC
+1C=FS
+1D=GS
+1E=RS
+1F=US
+20= 
+21=!
+22="
+23=#
+24=$
+25=%
+26=&
+27='
+28=(
+29=)
+2A=*
+2B=+
+2C=,
+2D=-
+2E=.
+2F=/
+30=0
+31=1
+32=2
+33=3
+34=4
+35=5
+36=6
+37=7
+38=8
+39=9
+3A=:
+3B=;
+3C=<
+3D==
+3E=>
+3F=?
+40=@
+41=A
+42=B
+43=C
+44=D
+45=E
+46=F
+47=G
+48=H
+49=I
+4A=J
+4B=K
+4C=L
+4D=M
+4E=N
+4F=O
+50=P
+51=Q
+52=R
+53=S
+54=T
+55=U
+56=V
+57=W
+58=X
+59=Y
+5A=Z
+5B=[
+5C=\
+5D=]
+5E=^
+5F=_
+60=`
+61=a
+62=b
+63=c
+64=d
+65=e
+66=f
+67=g
+68=h
+69=i
+6A=j
+6B=k
+6C=l
+6D=m
+6E=n
+6F=o
+70=p
+71=q
+72=r
+73=s
+74=t
+75=u
+76=v
+77=w
+78=x
+79=y
+7A=z
+7B={
+7C=|
+7D=}
+7E=~
+7F=DEL
+80=€
+81=
+82=‚
+83=ƒ
+84=„
+85=…
+86=†
+87=‡
+88=ˆ
+89=‰
+8A=Š
+8B=‹
+8C=Œ
+8D=
+8E=Ž
+8F=
+90=
+91=‘
+92=’
+93=“
+94=”
+95=•
+96=–
+97=—
+98=˜
+99=™
+9A=š
+9B=›
+9C=œ
+9D=
+9E=ž
+9F=Ÿ
+A0= 
+A1=¡
+A2=¢
+A3=£
+A4=¤
+A5=¥
+A6=¦
+A7=§
+A8=¨
+A9=©
+AA=ª
+AB=«
+AC=¬
+AD=­
+AE=®
+AF=¯
+B0=°
+B1=±
+B2=²
+B3=³
+B4=´
+B5=µ
+B6=¶
+B7=·
+B8=¸
+B9=¹
+BA=º
+BB=»
+BC=¼
+BD=½
+BE=¾
+BF=¿
+C0=À
+C1=Á
+C2=Â
+C3=Ã
+C4=Ä
+C5=Å
+C6=Æ
+C7=Ç
+C8=È
+C9=É
+CA=Ê
+CB=Ë
+CC=Ì
+CD=Í
+CE=Î
+CF=Ï
+D0=Ğ
+D1=Ñ
+D2=Ò
+D3=Ó
+D4=Ô
+D5=Õ
+D6=Ö
+D7=×
+D8=Ø
+D9=Ù
+DA=Ú
+DB=Û
+DC=Ü
+DD=İ
+DE=Ş
+DF=ß
+E0=à
+E1=á
+E2=â
+E3=ã
+E4=ä
+E5=å
+E6=æ
+E7=ç
+E8=è
+E9=é
+EA=ê
+EB=ë
+EC=ì
+ED=í
+EE=î
+EF=ï
+F0=ğ
+F1=ñ
+F2=ò
+F3=ó
+F4=ô
+F5=õ
+F6=ö
+F7=÷
+F8=ø
+F9=ù
+FA=ú
+FB=û
+FC=ü
+FD=ı
+FE=ş
+FF=ÿ

encodings/turkish_windows.tbl

@@ -0,0 +1,256 @@
+00=NUL
+01=SOH
+02=STX
+03=ETX
+04=EOT
+05=ENQ
+06=ACK
+07=BEL
+08=BS
+09=TAB
+0A=LF
+0B=VT
+0C=FF
+0D=CR
+0E=SO
+0F=SI
+10=DLE
+11=DC1
+12=DC2
+13=DC3
+14=DC4
+15=NAK
+16=SYN
+17=ETB
+18=CAN
+19=EM
+1A=SUB
+1B=ESC
+1C=FS
+1D=GS
+1E=RS
+1F=US
+20= 
+21=!
+22="
+23=#
+24=$
+25=%
+26=&
+27='
+28=(
+29=)
+2A=*
+2B=+
+2C=,
+2D=-
+2E=.
+2F=/
+30=0
+31=1
+32=2
+33=3
+34=4
+35=5
+36=6
+37=7
+38=8
+39=9
+3A=:
+3B=;
+3C=<
+3D==
+3E=>
+3F=?
+40=@
+41=A
+42=B
+43=C
+44=D
+45=E
+46=F
+47=G
+48=H
+49=I
+4A=J
+4B=K
+4C=L
+4D=M
+4E=N
+4F=O
+50=P
+51=Q
+52=R
+53=S
+54=T
+55=U
+56=V
+57=W
+58=X
+59=Y
+5A=Z
+5B=[
+5C=\
+5D=]
+5E=^
+5F=_
+60=`
+61=a
+62=b
+63=c
+64=d
+65=e
+66=f
+67=g
+68=h
+69=i
+6A=j
+6B=k
+6C=l
+6D=m
+6E=n
+6F=o
+70=p
+71=q
+72=r
+73=s
+74=t
+75=u
+76=v
+77=w
+78=x
+79=y
+7A=z
+7B={
+7C=|
+7D=}
+7E=~
+7F=DEL
+80=€
+81
+82=‚
+83=ƒ
+84=„
+85=…
+86=†
+87=‡
+88=ˆ
+89=‰
+8A=Š
+8B=‹
+8C=Œ
+8D
+8E
+8F
+90
+91=‘
+92=’
+93=“
+94=”
+95=•
+96=–
+97=—
+98=˜
+99=™
+9A=š
+9B=›
+9C=œ
+9D
+9E
+9F=Ÿ
+A0= 
+A1=¡
+A2=¢
+A3=£
+A4=¤
+A5=¥
+A6=¦
+A7=§
+A8=¨
+A9=©
+AA=ª
+AB=«
+AC=¬
+AD=­
+AE=®
+AF=¯
+B0=°
+B1=±
+B2=²
+B3=³
+B4=´
+B5=µ
+B6=¶
+B7=·
+B8=¸
+B9=¹
+BA=º
+BB=»
+BC=¼
+BD=½
+BE=¾
+BF=¿
+C0=À
+C1=Á
+C2=Â
+C3=Ã
+C4=Ä
+C5=Å
+C6=Æ
+C7=Ç
+C8=È
+C9=É
+CA=Ê
+CB=Ë
+CC=Ì
+CD=Í
+CE=Î
+CF=Ï
+D0=Ğ
+D1=Ñ
+D2=Ò
+D3=Ó
+D4=Ô
+D5=Õ
+D6=Ö
+D7=×
+D8=Ø
+D9=Ù
+DA=Ú
+DB=Û
+DC=Ü
+DD=İ
+DE=Ş
+DF=ß
+E0=à
+E1=á
+E2=â
+E3=ã
+E4=ä
+E5=å
+E6=æ
+E7=ç
+E8=è
+E9=é
+EA=ê
+EB=ë
+EC=ì
+ED=í
+EE=î
+EF=ï
+F0=ğ
+F1=ñ
+F2=ò
+F3=ó
+F4=ô
+F5=õ
+F6=ö
+F7=÷
+F8=ø
+F9=ù
+FA=ú
+FB=û
+FC=ü
+FD=ı
+FE=ş
+FF=ÿ

encodings/vietnamese.tbl

@@ -0,0 +1,256 @@
+00=NUL
+01=SOH
+02=STX
+03=ETX
+04=EOT
+05=ENQ
+06=ACK
+07=BEL
+08=BS
+09=TAB
+0A=LF
+0B=VT
+0C=FF
+0D=CR
+0E=SO
+0F=SI
+10=DLE
+11=DC1
+12=DC2
+13=DC3
+14=DC4
+15=NAK
+16=SYN
+17=ETB
+18=CAN
+19=EM
+1A=SUB
+1B=ESC
+1C=FS
+1D=GS
+1E=RS
+1F=US
+20= 
+21=!
+22="
+23=#
+24=$
+25=%
+26=&
+27='
+28=(
+29=)
+2A=*
+2B=+
+2C=,
+2D=-
+2E=.
+2F=/
+30=0
+31=1
+32=2
+33=3
+34=4
+35=5
+36=6
+37=7
+38=8
+39=9
+3A=:
+3B=;
+3C=<
+3D==
+3E=>
+3F=?
+40=@
+41=A
+42=B
+43=C
+44=D
+45=E
+46=F
+47=G
+48=H
+49=I
+4A=J
+4B=K
+4C=L
+4D=M
+4E=N
+4F=O
+50=P
+51=Q
+52=R
+53=S
+54=T
+55=U
+56=V
+57=W
+58=X
+59=Y
+5A=Z
+5B=[
+5C=\
+5D=]
+5E=^
+5F=_
+60=`
+61=a
+62=b
+63=c
+64=d
+65=e
+66=f
+67=g
+68=h
+69=i
+6A=j
+6B=k
+6C=l
+6D=m
+6E=n
+6F=o
+70=p
+71=q
+72=r
+73=s
+74=t
+75=u
+76=v
+77=w
+78=x
+79=y
+7A=z
+7B={
+7C=|
+7D=}
+7E=~
+7F=DEL
+80=€
+81
+82=‚
+83=ƒ
+84=„
+85=…
+86=†
+87=‡
+88=ˆ
+89=‰
+8A
+8B=‹
+8C=Œ
+8D
+8E
+8F
+90
+91=‘
+92=’
+93=“
+94=”
+95=•
+96=–
+97=—
+98=˜
+99=™
+9A
+9B=›
+9C=œ
+9D
+9E
+9F=Ÿ
+A0= 
+A1=¡
+A2=¢
+A3=£
+A4=¤
+A5=¥
+A6=¦
+A7=§
+A8=¨
+A9=©
+AA=ª
+AB=«
+AC=¬
+AD=­
+AE=®
+AF=¯
+B0=°
+B1=±
+B2=²
+B3=³
+B4=´
+B5=µ
+B6=¶
+B7=·
+B8=¸
+B9=¹
+BA=º
+BB=»
+BC=¼
+BD=½
+BE=¾
+BF=¿
+C0=À
+C1=Á
+C2=Â
+C3=Ă
+C4=Ä
+C5=Å
+C6=Æ
+C7=Ç
+C8=È
+C9=É
+CA=Ê
+CB=Ë
+CC=̀
+CD=Í
+CE=Î
+CF=Ï
+D0=Đ
+D1=Ñ
+D2=̉
+D3=Ó
+D4=Ô
+D5=Ơ
+D6=Ö
+D7=×
+D8=Ø
+D9=Ù
+DA=Ú
+DB=Û
+DC=Ü
+DD=Ư
+DE=̃
+DF=ß
+E0=à
+E1=á
+E2=â
+E3=ă
+E4=ä
+E5=å
+E6=æ
+E7=ç
+E8=è
+E9=é
+EA=ê
+EB=ë
+EC=́
+ED=í
+EE=î
+EF=ï
+F0=đ
+F1=ñ
+F2=̣
+F3=ó
+F4=ô
+F5=ơ
+F6=ö
+F7=÷
+F8=ø
+F9=ù
+FA=ú
+FB=û
+FC=ü
+FD=ư
+FE=₫
+FF=ÿ

includes/cstdint.pat

@@ -1,16 +0,0 @@
-#pragma once
-
-using uint8_t       = u8;
-using uint16_t      = u16;
-using uint32_t      = u32;
-using uint64_t      = u64;
-using uint128_t     = u128;
-
-using int8_t        = s8;
-using int16_t       = s16;
-using int32_t       = s32;
-using int64_t       = s64;
-using int128_t      = s128;
-
-using size_t        = u32;
-using ssize_t       = s32;

includes/hex/core.pat

@@ -0,0 +1,50 @@
+#pragma once
+
+import hex.impl.imhex_check;
+
+/*!
+    Core intrinsic functions to interact with the ImHex Hex Editor
+*/
+
+namespace auto hex::core {
+
+    /**
+        A type representing a selection in the hex editor
+    */
+    struct Selection {
+        bool valid;
+        u64 address, size;
+    };
+
+    /**
+        Returns the current selection in the hex editor
+        @return The current selection
+    */
+    fn get_selection() {
+        u128 selection = builtin::hex::core::get_selection();
+
+        Selection result;
+        if (selection == u128(-1)) {
+            result.valid    = false;
+            result.address  = 0x00;
+            result.size     = 0x00;
+        } else {
+            result.valid    = true;
+            result.address  = selection >> 64;
+            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

@@ -0,0 +1,75 @@
+#pragma once
+
+import hex.impl.imhex_check;
+
+import std.mem;
+
+/*!
+    Library to allow decoding of more complex values
+*/
+
+namespace auto hex::dec {
+
+    /**
+        Demangles a mangled name into a human readable name
+        @param mangled_name The mangled name
+        @return The demangled name
+    */
+    fn demangle(str mangled_name) {
+        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 true if successful, false otherwise
+    */
+    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

@@ -0,0 +1,20 @@
+#pragma once
+
+import hex.impl.imhex_check;
+
+/*!
+    Library to do HTTP requests
+*/
+
+namespace auto hex::http {
+
+    /**
+        Performs a HTTP GET request to the given URL and returns the response body
+        @param url URL to perform the request to
+        @return Response body
+    */
+    fn get(str url) {
+        return builtin::hex::http::get(url);
+    };
+
+}

includes/hex/impl/imhex_check.pat

@@ -0,0 +1,7 @@
+#ifndef __PL_UNIT_TESTS__
+    #ifndef __IMHEX__
+
+        #error This library is only available in the ImHex Hex editor
+
+    #endif
+#endif

includes/hex/provider.pat

@@ -0,0 +1,43 @@
+#pragma once
+
+import hex.impl.imhex_check;
+
+/*!
+    Library to interact with the currently loaded provider.
+*/
+
+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`
+        >   - `file_name() -> str`
+        >   - `file_extension() -> str`
+        >   - `creation_time() -> time_t`
+        >   - `access_time() -> time_t`
+        >   - `modification_time() -> time_t`
+        >   - `permissions() -> u16`
+        > - Disk Provider
+        >   - `file_path() -> str`
+        >   - `sector_size() -> u128`
+        > - GDB Provider
+        >   - `ip() -> str`
+        >   - `port() -> u16`
+        > - Process Memory Provider
+        >   - `region_address(regionName) -> u64`
+        >   - `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]];
+        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]];
+        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]];
+        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]];
+        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]];
+        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]];
+        builtin::hex::dec::Ubjson<__data> ubjson [[merge]];
+    };
+    
+}
+

includes/hex/type/mangled.pat

@@ -0,0 +1,30 @@
+#pragma once
+
+import std.io;
+import std.mem;
+
+import hex.impl.imhex_check;
+import hex.dec;
+
+/*!
+    Types to automatically decode mangled names
+*/
+
+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

@@ -0,0 +1,52 @@
+#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.
+*/
+
+namespace auto std {
+
+    /**
+        Simple one dimensional array wrapper
+        @tparam T The array types
+        @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,39 +1,67 @@
 #pragma once
 
-#include <std/limits.pat>
+import std.limits;
 
-namespace std::bit {
+/*!
+    This library contains various helper functions for common bit operations.
+*/
 
-	fn popcount(u128 x) {
-		x = (x & (std::limits::u128_max() /  3)) + ((x >> 1) & (std::limits::u128_max() /  3));
-		x = (x & (std::limits::u128_max() /  5)) + ((x >> 2) & (std::limits::u128_max() /  5));
-		x = (x & (std::limits::u128_max() / 17)) + ((x >> 4) & (std::limits::u128_max() / 17));
-		
-		return x % 0xFF;
-	};
+namespace auto std::bit {
 
-	fn has_single_bit(u128 x) {
-		return x != 0 && (x & (x - 1)) == 0;
-	};
-	
-	fn bit_ceil(u128 x) {		
-		if (x == 0) return 0;
-		
-		u8 i;
-		while ((1 << i) < x)
-			i = i + 1;
-		
-		return 1 << i;
-	};
-	
-	fn bit_floor(u128 x) {
-		if (x == 0) return 0;
-		
-		u8 i;
-		while ((x >> i) > 0)
-			i = i + 1;
-		
-		return 1 << (i - 1);
-	};
+    /**
+        Calculates the number of 1 bits in a given number
+        @param x The number
+        @return The number of bits set to 1 in `x`
+    */
+    fn popcount(u128 x) {
+        const u128 a = 0x55555555555555555555555555555555;
+        const u128 b = 0x33333333333333333333333333333333;
+        const u128 c = 0x0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F;
+
+        x = (x & a) + ((x >> 1) & a);
+        x = (x & b) + ((x >> 2) & b);
+        x = (x & c) + ((x >> 4) & c);
+
+        return x % 0xFF;
+    };
+
+    /**
+        Checks if only a single bit is set to 1 in a given number
+        @param x The number
+        @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;
+    };
+
+    /**
+        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/cint.pat

@@ -1,23 +0,0 @@
-#pragma once
-
-namespace std {
-
-    using uint8_t   = u8;
-    using uint16_t  = u16;
-    using uint32_t  = u32;
-    using uint64_t  = u64;
-    using uint128_t = u128;
-
-    using int8_t   = s8;
-    using int16_t  = s16;
-    using int32_t  = s32;
-    using int64_t  = s64;
-    using int128_t = s128;
-
-    using float32_t = float;
-    using float64_t = double;
-
-    using size_t = u64;
-    using ssize_t = s64;
-
-}

includes/std/core.pat

@@ -0,0 +1,192 @@
+#pragma once
+
+import std.mem;
+
+/*!
+    The core library contains intrinsics and "compiler magic" functions that
+    get extra help from the runtime to fulfill their purpose.
+*/
+
+namespace auto std::core {
+
+    /**
+        The layout order of each field after byte-endianness has been handled.
+
+        `LeftToRight` and `RightToLeft` are deprecated in favor of the clearer `MostToLeastSignificant` and `LeastToMostSignificant` names.
+    */
+    enum BitfieldOrder : u8 {
+        /**
+            @warning deprecated
+        */
+        LeftToRight = 0,
+        /**
+            @warning deprecated
+        */
+        RightToLeft = 1,
+        MostToLeastSignificant = 0,
+        LeastToMostSignificant = 1
+    };
+
+
+    /**
+        Checks if a pattern has a specific attribute assigned to it
+        @param pattern The pattern to check
+        @param attribute The attribute's name to check for
+    */
+    fn has_attribute(ref auto pattern, str attribute) {
+        return builtin::std::core::has_attribute(pattern, attribute);
+    };
+
+    /**
+        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) {
+        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 endianness.
+        Any patterns created following this attribute will be created using the set endianness.
+        @param endian The new default endianness
+    */
+    fn set_endian(std::mem::Endian endian) {
+        builtin::std::core::set_endian(u32(endian));
+    };
+
+    /**
+        Gets the current default endianness.
+        @return The currently set default endianness
+    */
+    fn get_endian() {
+        return builtin::std::core::get_endian();
+    };
+
+    
+    /**
+        @warning Removed in 1.28.0
+    */
+    fn set_bitfield_order(BitfieldOrder order) {
+        builtin::std::error("Runtime default bitfield order is no longer supported.\nConsider using `be` or `le` on your bitfield variables,\nor attach attribute `bitfield_order` to the bitfield.");
+    };
+
+    /**
+        @warning Removed in 1.28.0
+    */
+    fn get_bitfield_order() {
+        builtin::std::error("Runtime default bitfield order is no longer supported.\nConsider using `be` or `le` on your bitfield variables,\nor attach attribute `bitfield_order` to the bitfield.");
+    };
+
+
+    /**
+        When used inside of a pattern that's being created using a pattern,
+        returns the current array index that's being processed.
+        If used outside of an array, always yields 0.
+        @return The current array index
+    */
+    fn array_index() {
+        return builtin::std::core::array_index();
+    };
+
+    /**
+        Queries the number of members of a struct, union or bitfield or the number of entries in an array
+        @param pattern The pattern to check
+        @return The number of members in `pattern`
+    */
+    fn member_count(ref auto pattern) {
+        return builtin::std::core::member_count(pattern);  
+    };
+
+    /**
+        Checks whether or not a given pattern has a member with a given name
+        @param pattern The pattern to check
+        @param name The name of the member to look for
+        @return True if a member called `name` exists, false otherwise
+    */
+    fn has_member(ref auto pattern, str name) {
+        return builtin::std::core::has_member(pattern, name);  
+    };
+
+    /**
+        Formats a pattern using it's default formatter or its custom formatter function set through
+        the `[[format]]` or `[[format_read]]` attribute
+        @param pattern The pattern to format
+        @return Formatted string representation of `pattern`
+    */
+    fn formatted_value(ref auto pattern) {
+        return builtin::std::core::formatted_value(pattern);
+    };
+
+    /**
+        Checks if the given enum value corresponds has a corresponding constant
+        @param pattern The enum value to check
+        @return True if pattern has a valid enum representation, false if not
+    */
+    fn is_valid_enum(ref auto pattern) {
+        return builtin::std::core::is_valid_enum(pattern);
+    };
+
+
+    /**
+        Changes the color of the given pattern to a new color
+        @param pattern The pattern to modify
+        @param color The RGBA8 color 
+    */
+    fn set_pattern_color(ref auto pattern, u32 color) {
+        builtin::std::core::set_pattern_color(pattern, color);
+    };
+
+    /**
+        Changes the display name of a given pattern
+        @param pattern The pattern to modify
+        @param name The new display name of the pattern
+    */
+    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

@@ -1,51 +1,116 @@
 #pragma once
 
-namespace std::ctype {
+/*!
+    The ctype library has functions to check if a character is part of a specific category
+    of ASCII characters.
+*/
 
+namespace auto std::ctype {
+
+    /**
+        Checks if the given character `c` is a digit between '0' and '9'
+        @param c The character to check
+        @return True if `c` is part of this range, false otherwise
+    */
     fn isdigit(char c) {
         return c >= '0' && c <= '9';
     };
 
+    /**
+        Checks if the given character `c` is a hexadecimal digit between '0' and '9', `A` and `F` or `a` and `f`
+        @param c The character to check
+        @return True if `c` is part of this range, false otherwise
+    */
     fn isxdigit(char c) {
         return std::ctype::isdigit(c) || (c >= 'A' && c <= 'F') || (c >= 'a' && c <= 'f');
     };
 
+    /**
+        Checks if the given character `c` is a upper case letter between 'A' and 'Z'
+        @param c The character to check
+        @return True if `c` is part of this range, false otherwise
+    */
     fn isupper(char c) {
         return c >= 'A' && c <= 'Z';
     };
 
+    /**
+        Checks if the given character `c` is a lower case letter between 'a' and 'z'
+        @param c The character to check
+        @return True if `c` is part of this range, false otherwise
+    */
     fn islower(char c) {
         return c >= 'a' && c <= 'z';
     };
 
+    /**
+        Checks if the given character `c` is either a upper or lower case letter between 'A' and 'Z' or 'a' and 'z'
+        @param c The character to check
+        @return True if `c` is part of this range, false otherwise
+    */
     fn isalpha(char c) {
         return std::ctype::isupper(c) || std::ctype::islower(c);
     };
 
+    /**
+        Checks if the given character `c` is a upper or lower case letter or a number
+        @param c The character to check
+        @return True if `c` is part of this range, false otherwise
+    */
     fn isalnum(char c) {
         return std::ctype::isalpha(c) || std::ctype::isdigit(c);
     };
 
+    /**
+        Checks if the given character `c` is a space character
+        @param c The character to check
+        @return True if `c` is part of this range, false otherwise
+    */
     fn isspace(char c) {
         return (c >= 0x09 && c <= 0x0D) || c == 0x20;
     };
 
+    /**
+        Checks if the given character `c` is a invisible character
+        @param c The character to check
+        @return True if `c` is part of this range, false otherwise
+    */
     fn isblank(char c) {
         return c == 0x09 || c == ' ';
     };
 
+    /**
+        Checks if the given character `c` has a printable glyph
+        @param c The character to check
+        @return True if `c` is part of this range, false otherwise
+    */
     fn isprint(char c) {
         return c >= '0' && c <= '~';
     };
 
+    /**
+        Checks if the given character `c` is a control code
+        @param c The character to check
+        @return True if `c` is part of this range, false otherwise
+    */
     fn iscntrl(char c) {
         return !std::ctype::isprint(c);
     };
 
+    /**
+        Checks if the given character `c` has a visible glyph
+        @param c The character to check
+        @return True if `c` is part of this range, false otherwise
+    */
     fn isgraph(char c) {
         return std::ctype::isprint(c) && !std::ctype::isspace(c);
     };
 
+    /**
+        Checks if the given character `c` is a punctuation character
+        @param c The character to check
+        @return True if `c` is part of this range, false otherwise
+    */
     fn ispunct(char c) {
         return std::ctype::isgraph(c) && !std::ctype::isalnum(c);
     };

includes/std/file.pat

@@ -1,49 +1,120 @@
 #pragma once
 
-namespace std::file {
+/*!
+    The File library allows reading and writing from/to external files using
+    a C-like File IO API.
 
-	using Handle = s32;
-	
-	enum Mode : u8 {
-		Read = 1,
-		Write = 2,
-		Create = 3
-	};
+    **These functions are considered dangerous and require the user to manually permit them**
+*/
+
+namespace auto std::file {
+
+    /**
+        A handle representing a file that has been opened
+    */
+    using Handle = s32;
+
+    /**
+        The mode to open a file in.
+        Read opens the file in read-only 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
+    */
+    enum Mode : u8 {
+        Read = 1,
+        Write = 2,
+        Create = 3
+    };
 
 
-	fn open(str path, Mode mode) {
-		return builtin::std::file::open(path, mode);
-	};
+    /**
+        Opens a file
+        @param path The path to the file to open
+        @param mode File open mode
+        @return Handle to the newly opened file
+    */
+    fn open(str path, Mode mode) {
+        return builtin::std::file::open(path, u32(mode));
+    };
 
-	fn close(Handle handle) {
-		builtin::std::file::close(handle);
-	};
-
-	
-	fn read(Handle handle, u64 size) {
-		return builtin::std::file::read(handle, size);
-	};
-
-	fn write(Handle handle, str data) {
-		return builtin::std::file::write(handle, data);
-	};
+    /**
+        Closes a file handle that has been opened previously
+        @param handle The handle to close
+    */
+    fn close(Handle handle) {
+        builtin::std::file::close(handle);
+    };
 
 
-	fn size(Handle handle) {
-		return builtin::std::file::size(handle);
-	};
+    /**
+        Reads the content of a file into a string
+        @param handle The file handle to read from
+        @param size Number of bytes to read
+        @return String containing the read data
+    */
+    fn read(Handle handle, u64 size) {
+        return builtin::std::file::read(handle, size);
+    };
 
-	fn resize(Handle handle, u64 size) {
-		builtin::std::file::resize(handle, size);
-	};
+    /**
+        Writes the content of a string into a file
+        @param handle The file handle to write to
+        @param data String or Pattern to write to the file
+    */
+    fn write(Handle handle, auto data) {
+        builtin::std::file::write(handle, data);
+    };
 
-	fn flush(Handle handle) {
-		builtin::std::file::remove(handle);
-	};
+    /**
+        Sets the current cursor position in the given file handle
+        @param handle The file handle to set the cursor position in
+        @param offset The offset to move the cursor to
+    */
+    fn seek(Handle handle, u64 offset) {
+        builtin::std::file::seek(handle, offset);
+    };
 
 
-	fn remove(Handle handle) {
-		builtin::std::file::remove(handle);
-	};
+    /**
+        Queries the size of a file
+        @param handle The handle of the file to get the size of
+        @return The file's size
+    */
+    fn size(Handle handle) {
+        return builtin::std::file::size(handle);
+    };
+
+    /**
+        Resizes a file
+        @param handle The handle of the file to resize
+    */
+    fn resize(Handle handle, u64 size) {
+        builtin::std::file::resize(handle, size);
+    };
+
+    /**
+        Flushes changes made to a file to disk
+        @param handle The handle of the file to flush
+    */
+    fn flush(Handle handle) {
+        builtin::std::file::flush(handle);
+    };
+
+
+    /**
+        Deletes a file from disk. This will also automatically close this file
+        @param handle The handle of the file to delete
+    */
+    fn remove(Handle 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,35 +1,89 @@
 #pragma once
 
-namespace std::fxpt {
+/*!
+    Library for doing arithmetic with fixed point numbers and converting them from/to floating point numbers.
+*/
 
-	using fixed = s128;
+namespace auto std::fxpt {
 
-	fn to_float(fixed fxt, u32 precision) {
-		return double(fxt) / double((1 << precision));
-	};
-	
-	fn to_fixed(double flt, u32 precision) {
-		return fixed((flt * (1 << precision)));
-	};
+    /**
+        A fixed point value
+    */
+    using fixed = s128;
 
-	fn change_precision(fixed value, u32 start_precision, u32 end_precision) {
-		return std::fxpt::to_fixed(std::fxpt::to_float(value, start_precision), end_precision);
-	};
-	
-	fn add(fixed a, fixed b, u32 precision) {
-		return a + b;
-	};
-	
-	fn subtract(fixed a, fixed b, u32 precision) {
-		return a - b;
-	};
-	
-	fn multiply(fixed a, fixed b, u32 precision) {
-		return (a * b) / (1 << precision);
-	};
-	
-	fn divide(fixed a, fixed b, u32 precision) {
-		return (a << precision) / b;
-	};
+    /**
+        Converts a fixed point value into a floating point value
+        @param fxt The fixed point value to convert
+        @param precision The bits of precision the new value should have
+        @return The floating point representation of fxt
+    */
+    fn to_float(fixed fxt, u32 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
+        @param value The fixed point value to convert
+        @param start_precision The current number of bits used
+        @param end_precision The new number of bits used
+        @return `value` as a new fixed point number with `end_precision` bits of precision
+    */
+    fn change_precision(fixed value, u32 start_precision, u32 end_precision) {
+        return std::fxpt::to_fixed(std::fxpt::to_float(value, start_precision), end_precision);
+    };
+
+    /**
+        Adds 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 addition of `a` and `b`
+    */
+    fn add(fixed a, fixed b, u32 precision) {
+        return a + b;
+    };
+
+    /**
+        Subtracts 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 subtraction of `a` and `b`
+    */
+    fn subtract(fixed a, fixed b, u32 precision) {
+        return a - b;
+    };
+
+    /**
+        Multiplies 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 multiplication of `a` and `b`
+    */
+    fn multiply(fixed a, fixed b, u32 precision) {
+        return (a * b) / (1 << precision);
+    };
+
+    /**
+        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

@@ -1,29 +1,65 @@
 #pragma once
 
-namespace std::hash {
+/*!
+    The hash library contains various data hash functions
+*/
 
-    fn crc32(u128 address, u64 size, u32 init, u32 poly) {
-        u8 byte;
-        u32 crc, mask;
-        
-        crc = init;
-        
-        u64 i;
-        while (i < size) {
-            byte = std::mem::read_unsigned(address + i, 1);
-            crc = crc ^ byte;
-            
-            u8 j;
-            while (j < 8) {
-                mask = u32(-(crc & 1));
-                crc = (crc >> 1) ^ (poly & mask);
-                j = j + 1;
-            }
-            
-            i = i + 1;
-        }
-        
-        return u32(~crc);
+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 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
+    */
+    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/http.pat

@@ -1,9 +0,0 @@
-#pragma once
-
-namespace std::http {
-
-    fn get(str url) {
-        return builtin::std::http::get(url);
-    };
-
-}

includes/std/io.pat

@@ -1,20 +1,45 @@
 #pragma once
 
-namespace std {
+/*!
+    The IO library allows formatting strings and outputting text to the console
+*/
 
-    fn print(str fmt, auto ... args) {
+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 or any other value that can be converted to a string
+        @param args Values to use in the formatting
+    */
+    fn print(auto fmt, auto ... args) {
         builtin::std::print(fmt, args);
     };
 
-    fn format(str fmt, auto ... 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 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(auto fmt, auto ... args) {
         return builtin::std::format(fmt, args);
     };
 
 
+    /**
+        Aborts evaluation of the code immediately and prints a error message to the console
+        @param message The message to print
+    */
     fn error(str message) {
         builtin::std::error(message);
     };
 
+    /**
+        Prints a warning message to the console
+        @param message The message to print
+    */
     fn warning(str message) {
         builtin::std::warning(message);
     };

includes/std/limits.pat

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

includes/std/math.pat

@@ -1,109 +1,340 @@
 #pragma once
 
-namespace std::math {
+import std.mem;
 
-	fn min(auto a, auto b) {
-		if (a < b)
-			return a;
-		else
-			return b;
-	};
-	
-	fn max(auto a, auto b) {
-		if (a > b)
-			return a;
-		else
-			return b;
-	};
+/*!
+    Library containing more advanced mathematical operations.
+*/
 
-	fn clamp(auto x, auto min, auto max) {
-		if (x < min)
-			return min;
-		else if (x > max)
-			return max;
-		else
-			return x;
-	};
+namespace auto std::math {
 
-	fn abs(auto x) {
-		if (x < 0) 
-			return -x;
-		else 
-			return x;
-	};
+    /**
+        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;
+    };
 
-	fn sign(auto x) {
-		if (x > 0)
-			return 1;
-		else if (x < 0)
-			return -1;
-		else
-			return 0;
-	};
+    /**
+        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;
+    };
 
-	fn copy_sign(auto x, auto y) {
-		if (y >= 0)
-			return std::math::abs(x);
-		else
-			return -std::math::abs(x);
-	};
+    /**
+        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;
+    };
 
-	fn factorial(u128 x) {
-		u128 result;
-		
-		result = x;
-		while (x > 1) {
-			x = x - 1;
-			result = result * x;
-		}
-		
-		return result;
-	};
+    /**
+        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;
+    };
 
-	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));
-	};
+    /**
+        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;
+    };
 
-	fn perm(u128 n, u128 k) {
-		if (k > n)
-			return 0;
-		else
-			return std::math::factorial(n) / std::math::factorial(n - k);
-	};
+    /**
+        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); };
 
 
-	fn floor(auto value) { return builtin::std::math::floor(value); };
-	fn ceil(auto value) { return builtin::std::math::ceil(value); };
-	fn round(auto value) { return builtin::std::math::round(value); };
-	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); };
 
-	fn log10(auto value) { return builtin::std::math::log10(value); };
-	fn log2(auto value) { return builtin::std::math::log2(value); };
-	fn ln(auto value) { return builtin::std::math::ln(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); };
 
-	fn fmod(auto value) { return builtin::std::math::fmod(value); };
-	fn pow(auto base, auto exp) { return builtin::std::math::pow(base, exp); };
-	fn sqrt(auto value) { return builtin::std::math::sqrt(value); };
-	fn cbrt(auto value) { return builtin::std::math::cbrt(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); };
 
-	fn sin(auto value) { return builtin::std::math::sin(value); };
-	fn cos(auto value) { return builtin::std::math::cos(value); };
-	fn tan(auto value) { return builtin::std::math::tan(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); };
 
-	fn asin(auto value) { return builtin::std::math::asin(value); };
-	fn acos(auto value) { return builtin::std::math::acos(value); };
-	fn atan(auto value) { return builtin::std::math::atan(value); };
-	fn atan2(auto value) { return builtin::std::math::atan2(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); };
 
-	fn sinh(auto value) { return builtin::std::math::sinh(value); };
-	fn cosh(auto value) { return builtin::std::math::cosh(value); };
-	fn tanh(auto value) { return builtin::std::math::tanh(value); };
+    /**
+        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`.
+        @param value Value
+        @return Square root of `value`
+    */
+    fn sqrt(auto value) { return builtin::std::math::sqrt(value); };
+
+    /**
+        Calculates the cubic root of `value`.
+        @param value Value
+        @return Cubic root of `value`
+    */
+    fn cbrt(auto value) { return builtin::std::math::cbrt(value); };
+
+    /**
+        Calculates the sine of `value`.
+        @param value Angle value in radians
+        @return Sine of `value`
+    */
+    fn sin(auto value) { return builtin::std::math::sin(value); };
+
+    /**
+        Calculates the cosine of `value`.
+        @param value Angle value in radians
+        @return Cosine of `value`
+    */
+    fn cos(auto value) { return builtin::std::math::cos(value); };
+
+    /**
+        Calculates the tangent of `value`.
+        @param value Angle value in radians
+        @return Tangent of `value`
+    */
+    fn tan(auto value) { return builtin::std::math::tan(value); };
+
+    /**
+        Calculates the arc sine of `value`.
+        @param value Angle value in radians
+        @return Arc sine of `value`
+    */
+    fn asin(auto value) { return builtin::std::math::asin(value); };
+
+    /**
+        Calculates the arc cosine of `value`.
+        @param value Value
+        @return Arc cosine of `value` in radians
+    */
+    fn acos(auto value) { return builtin::std::math::acos(value); };
+
+    /**
+        Calculates the arc tangent of `value`.
+        @param value Value
+        @return Arc tangent of `value` in radians between `-pi/2` and `pi/2`
+    */
+    fn atan(auto value) { return builtin::std::math::atan(value); };
+
+    /**
+        Calculates the arc tangent of `value`.
+        @param y Value representing the proportion of the y-coordinate
+        @param x Value representing the proportion of the x-coordinate.
+        @return Arc tangent of `value` in radians between `-pi` and `pi`
+    */
+    fn atan2(auto y, auto x) { return builtin::std::math::atan2(y, x); };
+
+    /**
+        Calculates the hyperbolic sine of `value`.
+        @param value Angle value in radians
+        @return Hyperbolic sine of `value`
+    */
+    fn sinh(auto value) { return builtin::std::math::sinh(value); };
+
+    /**
+        Calculates the hyperbolic cosine of `value`.
+        @param value Angle value in radians
+        @return Hyperbolic cosine of `value`
+    */
+    fn cosh(auto value) { return builtin::std::math::cosh(value); };
+
+    /**
+        Calculates the hyperbolic tangent of `value`.
+        @param value Angle value in radians
+        @return Hyperbolic tangent of `value`
+    */
+    fn tanh(auto value) { return builtin::std::math::tanh(value); };
+
+
+    /**
+        Calculates the arc hyperbolic sine of `value`.
+        @param value Value
+        @return Arc hyperbolic sine of `value`
+    */
+    fn asinh(auto value) { return builtin::std::math::asinh(value); };
+
+    /**
+        Calculates the arc hyperbolic cosine of `value`.
+        @param value Value
+        @return Arc hyperbolic cosine of `value`
+    */
+    fn acosh(auto value) { return builtin::std::math::acosh(value); };
+
+    /**
+        Calculates the arc hyperbolic tangent of `value`.
+        @param value Value
+        @return Arc hyperbolic tangent of `value`
+    */
+    fn atanh(auto value) { return builtin::std::math::atanh(value); };
+
+
+    /**
+        Options to use with the `std::math::accumulate` function.
+    */
+    enum AccumulateOperation : u8 {
+        Add         = 0,
+        Multiply    = 1,
+        Modulo      = 2,
+        Min         = 3,
+        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));
+    };
 
-	fn asinh(auto value) { return builtin::std::math::asinh(value); };
-	fn acosh(auto value) { return builtin::std::math::acosh(value); };
-	fn atanh(auto value) { return builtin::std::math::atanh(value); };
-	
 }

includes/std/mem.pat

@@ -1,44 +1,290 @@
 #pragma once
 
-namespace std::mem {
-  
-    fn eof() {
-        return $ >= std::mem::size();
+/*!
+    Library for doing raw memory accesses and other low-level operations.
+*/
+
+namespace auto std::mem {
+
+    namespace impl {
+
+        struct MagicSearchImpl<auto Magic, T> {
+            s128 address = builtin::std::mem::find_string_in_range(0, $, builtin::std::mem::size(), Magic);
+            if (address < 0)
+                break;
+
+            $ = address;
+            try {
+                T data [[inline]];
+            } catch {
+                T data;
+            }
+        };
+
+    }
+
+    /**
+        A Handle for a custom Section
+     */
+    using Section = u128;
+
+    /**
+        The endianness of a value
+     */
+    enum Endian : u8 {
+        Native  = 0,
+        Big     = 1,
+        Little  = 2
     };
 
+    /**
+        Function that returns true if the cursor position is at the end of the memory
+        This is usually used in while-sized arrays in the form of `u8 array[while(!std::mem::eof())]`
+        @return True if the cursor is at the end of the memory
+     */
+    fn eof() {
+        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;
+    };
+
+    /**
+        Aligns the given value to the given alignment
+        @param alignment The alignment to align to
+        @param value The value to align
+        @return The aligned value
+    */
     fn align_to(u128 alignment, u128 value) {
         u128 remainder = value % alignment;
 
         return remainder != 0 ? value + (alignment - remainder) : value;
     };
-  
 
+
+    /**
+        Gets the base address of the data
+        @return The base address of the memory
+     */
     fn base_address() {
         return builtin::std::mem::base_address();
     };
 
+    /**
+        Gets the size of the data
+        @return The size of the memory
+     */
     fn size() {
         return builtin::std::mem::size();
     };
 
+    /**
+        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 = builtin::std::mem::base_address();
+        return builtin::std::mem::find_sequence_in_range(occurrence_index, address, address + builtin::std::mem::size(), bytes);
     };
 
+    /**
+        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
+        @param bytes The bytes to find
+        @return The address of the sequence
+    */
     fn find_sequence_in_range(u128 occurrence_index, u128 offsetFrom, u128 offsetTo, auto ... bytes) {
         return builtin::std::mem::find_sequence_in_range(occurrence_index, offsetFrom, offsetTo, bytes);
     };
 
-    fn read_unsigned(u128 address, u8 size) {
-        return builtin::std::mem::read_unsigned(address, size);
+
+    /**
+        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 = builtin::std::mem::base_address();
+        return builtin::std::mem::find_string_in_range(occurrence_index, address, address + builtin::std::mem::size(), string);
     };
 
-    fn read_signed(u128 address, u8 size) {
-        return builtin::std::mem::read_signed(address, size);
+    /**
+        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);
     };
 
-    fn read_string(u128 address, u8 size) {
+    /**
+        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 endianness of the value to read. Defaults to native
+        @return The value read
+    */
+    fn read_unsigned(u128 address, u8 size, Endian endian = Endian::Native) {
+        return builtin::std::mem::read_unsigned(address, size, u32(endian));
+    };
+
+    /**
+        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 endianness of the value to read. Defaults to native
+        @return The value read
+    */
+    fn read_signed(u128 address, u8 size, Endian endian = Endian::Native) {
+        return builtin::std::mem::read_signed(address, size, u32(endian));
+    };
+
+    /**
+        Reads a string value from the memory
+        @param address The address to read from
+        @param size The size of the value to read
+        @return The value read
+    */
+    fn read_string(u128 address, u128 size) {
         return builtin::std::mem::read_string(address, size);
     };
 
+    /**
+        Reads a number of bits from the specified bit offset within the specified byte
+        @param byteOffset The byte offset within the data
+        @param bitOffset The bit offset to start the read at within the current byte
+        @param bitSize The total number of bits to read
+        @return A u128 containing the value read
+    */
+    fn read_bits(u128 byteOffset, u128 bitOffset, u64 bitSize) {
+        byteOffset += bitOffset >> 3;
+        bitOffset = bitOffset & 0x7;
+        return builtin::std::mem::read_bits(byteOffset, bitOffset, bitSize);
+    };
+
+
+    /**
+        Creates a new custom section with the given name
+        @param name The name of the section
+        @return The handle to the section
+    */
+    fn create_section(str name) {
+        return builtin::std::mem::create_section(name);
+    };
+
+    /**
+        Deletes a custom section
+        @param section The handle to the section
+    */
+    fn delete_section(Section section) {
+        builtin::std::mem::delete_section(section);
+    };
+
+    /**
+        Gets the size of a custom section
+        @param section The handle to the section
+        @return The size of the section
+    */
+    fn get_section_size(Section section) {
+        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
+        @param from_address The address to copy from
+        @param to_section The section to copy to
+        @param to_address The address to copy to
+        @param size The size of the range to copy
+    */
+    fn copy_section_to_section(Section from_section, u64 from_address, Section to_section, u64 to_address, u64 size) {
+        builtin::std::mem::copy_to_section(from_section, from_address, to_section, to_address, size);
+    };
+
+    /**
+        Copies a range of bytes from the main section into a custom section
+        @param value The pattern whose bytes should be copied
+        @param to_section The section to copy to
+        @param to_address The address to copy to
+    */
+    fn copy_value_to_section(ref auto value, Section to_section, u64 to_address) {
+        builtin::std::mem::copy_value_to_section(value, to_section, to_address);
+    };
+
+    /**
+        Returns the current bit offset when inside of a bitfield.
+        @return The current bit offset between 0 and 7
+    */
+    fn current_bit_offset() {
+        return builtin::std::mem::current_bit_offset();
+    };
+
+
+    /**
+        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]];
+    };
+
+    /**
+        Reinterprets a value as a different one
+        @tparam From The type to reinterpret from
+        @tparam To The type to reinterpret to
+    */
+    union Reinterpreter<From, To> {
+        From from_value;
+        To to_value;
+    };
+
+
+    /**
+        Aligns the cursor to the given alignment
+        @tparam alignment The alignment to align to
+    */
+    struct AlignTo<auto Alignment> {
+        padding[Alignment - ((($ - 1) % Alignment) + 1)];
+    } [[hidden, sealed]];
+
+    /**
+        A type representing a sequence of bytes without any specific meaning
+        @tparam Size The size of the sequence
+    */
+    struct Bytes<auto Size> {
+        u8 bytes[Size];
+    } [[sealed, format("std::mem::impl::format_bytes")]];
+
+    namespace impl {
+
+        fn format_bytes(auto bytes) {
+            return "";
+        };
+
+    }
+
 }

includes/std/ptr.pat

@@ -1,17 +1,69 @@
 #pragma once
 
-namespace std::ptr {
+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 auto std::ptr {
+
+    /**
+        Use the offset of the current pointer as start address
+        @param offset The pointer's value
+        @return The new pointer base
+    */
     fn relative_to_pointer(u128 offset) {
         return $;
     };
 
+    /**
+        Use the offset of the pointer's parent as start address
+        @param offset The pointer's value
+        @return The new pointer base
+    */
     fn relative_to_parent(u128 offset) {
         return addressof(parent);
     };
 
+    /**
+        Use the end of the file as pointer base address and use its value as offset backwards from there
+        @param offset The pointer's value
+        @return The new pointer base
+    */
     fn relative_to_end(u128 offset) {
         return std::mem::size() - offset * 2;
     };
 
-}
+    /**
+    A nullable pointer, generic over both the pointee type and pointer type.
+
+    By nullable, we mean that if the pointer's value is zero (`0x0`), then the
+    value will appear as padding rather than a pointer to something, but
+    if the pointer's value is non-zero, that non-zero value will be treated as
+    a pointer of type `PointerTy` which points to an element of type `PointeeTy`.
+
+    Example:
+    A struct field called `p_myInfo` which is a nullable 64-bit pointer to an
+    element of type `MyInfoTy` would be written as:
+    ```
+    struct MyStruct {
+      std::ptr::NullablePtr<MyInfoTy, u64> p_myInfo;
+    }
+    ```
+    */
+    struct NullablePtr<PointeeTy, PointerTy> {
+        // `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
+        // padding or the populated pointer/pointee field.
+        PointerTy pointerValue [[no_unique_address, hidden]];
+        if (pointerValue == 0x0) {
+            padding[sizeof(PointerTy)];
+        } else {
+            PointeeTy *data : PointerTy;
+        }
+    };
+}

includes/std/random.pat

@@ -0,0 +1,81 @@
+#pragma once
+
+import std.limits;
+
+/*!
+  Library to generate random numbers. Supports various different distribution types.
+*/
+
+namespace auto std::random {
+
+    /**
+        Represents the type of distribution to use to generate a random number
+    */
+    enum Distribution : u8 {
+        Uniform           = 0,
+        Normal            = 1,
+        Exponential       = 2,
+        Gamma             = 3,
+        Weibull           = 4,
+        ExtremeValue      = 5,
+        ChiSquared        = 6,
+        Cauchy            = 7,
+        FisherF           = 8,
+        StudentT          = 9,
+        LogNormal         = 10,
+        Bernoulli         = 11,
+        Binomial          = 12,
+        NegativeBinomial  = 13,
+        Geometric         = 14,
+        Poisson           = 15
+    };
+
+    /**
+        Sets the seed of the random number generator
+        @param seed Seed to use
+    */
+    fn set_seed(u64 seed) {
+        builtin::std::random::set_seed(seed);
+    };
+
+    /**
+        Generates a random number using the given distribution with the given parameters.
+        The random number generator used internally is C++'s std::mt19937_64 Mersenne Twister implementation.
+
+        > **Distributions**
+        > - `Uniform(min, max) -> i128`
+        > - `Normal(mean, stddev) -> double`
+        > - `Exponential(lambda) -> double`
+        > - `Gamma(alpha, beta) -> double`
+        > - `Weibull(a, b) -> double`
+        > - `ExtremeValue(a, b) -> double`
+        > - `ChiSquared(n) -> double`
+        > - `Cauchy(a, b) -> double`
+        > - `FisherF(m, n) -> double`
+        > - `StudentT(n) -> double`
+        > - `LogNormal(m, s) -> double`
+        > - `Bernoulli(p) -> bool`
+        > - `Binomial(t, p) -> i128`
+        > - `NegativeBinomial(k, p) -> i128`
+        > - `Geometric(p) -> i128`
+        > - `Poisson(mean) -> i128`
+
+        @param distribution Distribution to use
+        @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. 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. Defaults to 0
+        @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/rustint.pat

@@ -1,17 +0,0 @@
-#pragma once
-
-namespace std {
-
-    using i8   = s8;
-    using i16  = s16;
-    using i32  = s32;
-    using i64  = s64;
-    using i128 = s128;
-
-    using f32 = float;
-    using f64 = double;
-
-    using usize = u64;
-    using isize = s64;
-    
-}

includes/std/string.pat

@@ -1,133 +1,259 @@
 #pragma once
 
-#include <std/io.pat>
+import std.io;
+import std.mem;
 
-namespace std::string {
+/*!
+    Library to interact with strings.
+*/
 
-	fn length(str string) {
-		return builtin::std::string::length(string);
-	};
+namespace auto std::string {
 
-	fn at(str string, u32 index) {
-		return builtin::std::string::at(string, index);
-	};
+    /**
+        Base type for sized strings. Represents a string with its size preceding it.
+        @tparam SizeType The type of the size field.
+        @tparam DataType The type of the characters.
+    */
+    struct SizedStringBase<SizeType, DataType> {
+        SizeType size;
+        DataType data[size];
+    } [[sealed, format("std::string::impl::format_string"), transform("std::string::impl::format_string")]];
 
-	fn substr(str string, u32 pos, u32 count) {
-		return builtin::std::string::substr(string, pos, count);
-	};
+    /**
+        A ASCII string with a prefixed size.
+        @tparam SizeType The type of the size field.
+    */
+    using SizedString<SizeType> = SizedStringBase<SizeType, char>;
+
+    /**
+        A UTF-16 string with a prefixed size.
+        @tparam SizeType The type of the size field.
+    */
+    using SizedString16<SizeType> = SizedStringBase<SizeType, char16>;
+
+    /**
+        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")]];
+
+    /**
+        A null-terminated ASCII string.
+    */
+    using NullString = NullStringBase<char>;
+
+    /**
+        A null-terminated UTF-16 string.
+    */
+    using NullString16 = NullStringBase<char16>;
+
+    namespace impl {
+
+        fn format_string(ref auto string) {
+            return string.data;
+        };
+
+    }
+
+    /**
+        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);
+    };
+
+    /**
+        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);
+    };
 
 
-	fn parse_int(str string, u8 base) {
-		return builtin::std::string::parse_int(string, base);
-	};
+    /**
+        Converts a string to an integer.
+        @param string The string to convert.
+        @param base The base of the number.
+        @return The integer.
+    */
+    fn parse_int(str string, u8 base) {
+        return builtin::std::string::parse_int(string, base);
+    };
 
-	fn parse_float(str string) {
-		return builtin::std::string::parse_float(string);
-	};
+    /**
+        Converts a string to a float.
+        @param string The string to convert.
+        @return The float.
+    */
+    fn parse_float(str string) {
+        return builtin::std::string::parse_float(string);
+    };
 
 
+    /**
+        Converts any type to a string.
+        @param x The value to convert.
+        @return The string.
+    */
     fn to_string(auto x) {
         return std::format("{}", x);
     };
 
+    /**
+        Checks if a string starts with a given substring.
+        @param string The string to check.
+        @param part The substring to check for.
+        @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.
+        @param string The string to check.
+        @param part The substring to check for.
+        @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;
     };
 
-    fn contains(str a, str b) {
-        s32 a_len, b_len;
-        a_len = std::string::length(a);
-        b_len = std::string::length(b);
+    /**
+        Checks if a string contains a given substring.
+        @param string The string to check.
+        @param part The substring to check for.
+        @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);
 
-        s32 i;
-        while (i < a_len - b_len) {
-            if (std::string::substr(a, i, b_len) == b)
+        for (s32 i = 0, i <= (string_len - part_len), i += 1) {
+            if (std::string::substr(string, i, part_len) == part)
                 return true;
-            i = i + 1;
         }
 
         return false;
     };
 
-    fn reverse(str string) {	
+    /**
+        Reverses a string.
+        @param string The string to reverse.
+        @return The reversed 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.
+        @param string The string to convert.
+        @return The converted string.
+    */
     fn to_upper(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;
-	};
-	
-	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;
-	};
+        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;
+    };
+
+    /**
+        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;
-		string_len  = std::string::length(string);
-		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;
-	};
+        s32 string_len  = std::string::length(string);
+        s32 pattern_len = std::string::length(pattern);
 
+        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,15 +1,29 @@
 #pragma once
 
-#include <std/io.pat>
+import std.io;
 
-namespace std {
+/*!
+    Basic helper functions
+*/
 
+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 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) {
         if (!condition) {
             std::error(std::format("assertion failed '{0}'", message));
         }
     };
 
+    /**
+        Asserts that a given value is true. If it's not, print the given message to the console as a warning
+        @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) {
         if (!condition) {
             std::warning(std::format("assertion failed '{0}'", message));
@@ -17,12 +31,29 @@ namespace std {
     };
 
 
+    /**
+        Queries the value of a set environment variable given it's name
+        @param name The name of the env variable
+        @return The value of that variable
+    */
     fn env(str name) {
         return builtin::std::env(name);
     };
 
+    /**
+        Returns the number of parameters in a parameter pack.
+        @param pack The pack to check
+        @return Number of parameters in `pack`
+    */
     fn sizeof_pack(auto ... pack) {
         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

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

@@ -1,100 +0,0 @@
-#include <std/io.pat>
-#include <std/math.pat>
-
-namespace std::type {
-
-    struct GUID {
-        u32 time_low;
-        u16 time_mid;
-        u16 time_high_and_version;
-        u8 clock_seq_and_reserved;
-        u8 clock_seq_low;
-        u8 node[6];
-    } [[format("std::type::guid_formatter"), single_color]];
-
-    fn guid_formatter(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));
-
-        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]);
-    };
-
-
-    using float16 = u16 [[format("std::type::float16_formatter")]];
-
-    fn float16_formatter(float16 value) {	
-        float sign = (value >> 15) == 0b01 ? -1.0 : 1.0;
-        float exponent = std::math::pow(2.0, float((value >> 10) & 0x1F) - 14);
-        u16 mantissa = value & 0x3FF;
-        
-        float fraction = 0;
-        for (s8 i = 9, i >= 0, i -= 1) {
-            if ((mantissa & (1 << i)) != 0) {
-                fraction += 1.0 / std::math::pow(2.0, (10.0 - i));
-            }
-        }
-
-        
-        return std::format("{:f}", sign * exponent * fraction);
-            
-    };
-
-
-    bitfield Bits {
-        bit0 : 1;
-        bit1 : 1;
-        bit2 : 1;
-        bit3 : 1;
-        bit4 : 1;
-        bit5 : 1;
-        bit6 : 1;
-        bit7 : 1;
-    } [[format("std::type::bits_formatter"), right_to_left]];
-    
-    bitfield Nibbles {
-        low  : 4;
-        high : 4;
-    } [[format("std::type::nibble_formatter")]];
-    
-    union Byte {
-        u8 value;
-        Bits bits;
-        Nibbles nibbles;
-    } [[format("std::type::byte_formatter"), single_color]];
-    
-    fn byte_formatter(Byte byte) {
-        return std::format("0x{0:02X} (0b{1:08b}) LSB:{2}, MSB:{3}",
-            byte.value,
-            byte.value,
-            byte.bits.bit0,
-            byte.bits.bit7);
-    };
-    
-    fn bits_formatter(Bits bits) {
-        return std::format("0b{}{}{}{}{}{}{}{}", 
-            bits.bit7,
-            bits.bit6,
-            bits.bit5,
-            bits.bit4,
-            bits.bit6,
-            bits.bit2,
-            bits.bit1,
-            bits.bit0);
-    };
-    
-    fn nibble_formatter(Nibbles nibbles) {
-        return std::format("{{ {0:0X}, {1:0X} }}", nibbles.high, nibbles.low);
-    };
-
-}

includes/type/base.pat

@@ -0,0 +1,55 @@
+#pragma once
+
+import std.io;
+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 auto type {
+    
+    /**
+        Integer type representing a Hexadecimal value. Displays its value in hexadecimal format.
+        @tparam T Integer type to use
+    */
+    using Hex<T> = T [[format("type::impl::format_hex")]];
+
+    /**
+        Integer type representing a Octal value. Displays its value in octal format.
+        @tparam T Integer type to use
+    */
+    using Oct<T> = T [[format("type::impl::format_oct")]];
+
+    /**
+        Integer type representing a Decimal value. Displays its value in decimal format.
+        @tparam T Integer type to use
+    */
+    using Dec<T> = T [[format("type::impl::format_dec")]];
+
+    /**
+        Integer type representing a Binary value. Displays its value in binary format.
+        @tparam T Integer type to use
+    */
+    using Bin<T> = T [[format("type::impl::format_bin")]];
+
+    namespace impl {
+
+            fn format_number(auto value, str fmt) {
+                bool negative = value < 0;
+            
+                if (negative)
+                    return std::format("-" + fmt, std::math::abs(value));
+                else
+                    return std::format(fmt, value);
+            };
+
+            fn format_hex(auto value) { return type::impl::format_number(value, "0x{:02X}"); };
+            fn format_oct(auto value) { return type::impl::format_number(value, "0o{:03o}"); };
+            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

@@ -0,0 +1,63 @@
+import std.io;
+import std.string;
+import std.mem;
+
+/*!
+    Type representing a Base64 encoded string
+*/
+
+namespace auto type {
+
+    /**
+        Type representing a Base64 encoded string
+        @tparam T String type
+    */
+    struct Base64<T> {
+        T string;
+    } [[sealed, format("type::impl::transform_base64")]];
+
+    namespace impl {
+
+        fn get_decoded_value(char c) {
+            if (c >= 'A' && c <= 'Z') return c - 'A';
+            if (c >= 'a' && c <= 'z') return c - 'a' + 26;
+            if (c >= '0' && c <= '9') return c - '0' + 52;
+            if (c == '+') return 62;
+            if (c == '/') return 63;
+            return -1; // Invalid character
+        };
+
+        fn decode_base64(str input) {
+            u64 inputLength = std::string::length(input);
+            str result;
+
+            s32 val = 0;
+            s32 bits = -8;
+            for (u32 i = 0, i < inputLength, i += 1) {
+                char c = input[i];
+                if (c == '=')
+                    break;
+
+                s32 index = type::impl::get_decoded_value(c);
+                if (index == -1)
+                    continue;
+
+                val = (val << 6) + index;
+                bits += 6;
+
+                if (bits >= 0) {
+                    result += char((val >> bits) & 0xFF);
+                    bits -= 8;
+                }
+            }
+
+            return result;
+        };
+
+        fn transform_base64(ref auto base64) {
+            return type::impl::decode_base64(base64.string);
+        };
+
+    }
+
+}

includes/type/bcd.pat

@@ -0,0 +1,37 @@
+#pragma once
+
+import std.io;
+
+/*!
+    Type to decode a BCD (Binary Coded Decimal) number
+*/
+
+namespace auto type {
+
+    /**
+        Decodes a BCD value where one byte represents a single digit
+        @tparam Digits Number of digits
+    */
+    struct BCD<auto Digits> {
+        u8 bytes[Digits];
+    } [[sealed, format_read("type::impl::format_bcd")]];
+
+    namespace impl {
+
+        fn format_bcd(ref auto bcd) {
+            str result;
+
+            for (u32 i = 0, i < sizeof(bcd.bytes), i += 1) {
+                u8 byte = bcd.bytes[i];
+                if (byte >= 10)
+                    return "Invalid";
+
+                result += std::format("{}", byte);
+            }
+
+            return result;
+        };
+
+    }
+
+}

includes/type/byte.pat

@@ -0,0 +1,72 @@
+#pragma once
+
+import std.io;
+import std.core;
+
+/*!
+    Types to display single bytes using various different representations
+*/
+
+namespace auto type {
+
+    /**
+        Type visualizing the value of each individual bit
+    */
+    bitfield Bits {
+        bit0 : 1;
+        bit1 : 1;
+        bit2 : 1;
+        bit3 : 1;
+        bit4 : 1;
+        bit5 : 1;
+        bit6 : 1;
+        bit7 : 1;
+    } [[format("type::impl::format_bits"), bitfield_order(std::core::BitfieldOrder::LeastToMostSignificant, 8)]];
+
+    /**
+        Type visualizing the value of the two nibbles
+    */
+    bitfield Nibbles {
+        low  : 4;
+        high : 4;
+    } [[format("type::impl::format_nibbles")]];
+
+    /**
+        Type representing a single Byte. Decodes the byte as it's hexadecimal value, individual bits and nibbles
+    */
+    union Byte {
+        u8 value;
+        Bits bits;
+        Nibbles nibbles;
+    } [[format("type::impl::format_byte"), single_color]];
+
+
+    namespace impl {
+
+        fn format_byte(Byte byte) {
+            return std::format("0x{0:02X} (0b{1:08b}) LSB:{2}, MSB:{3}",
+                byte.value,
+                byte.value,
+                byte.bits.bit0,
+                byte.bits.bit7);
+        };
+
+        fn format_bits(Bits bits) {
+            return std::format("0b{}{}{}{}{}{}{}{}",
+                bits.bit7,
+                bits.bit6,
+                bits.bit5,
+                bits.bit4,
+                bits.bit6,
+                bits.bit2,
+                bits.bit1,
+                bits.bit0);
+        };
+
+        fn format_nibbles(Nibbles nibbles) {
+            return std::format("{{ {0:0X}, {1:0X} }}", nibbles.high, nibbles.low);
+        };
+
+    }
+
+}

includes/type/color.pat

@@ -0,0 +1,80 @@
+#pragma once
+
+import std.io;
+import std.core;
+
+/*!
+    Types representing RGB or RGBA colors. The decoded color will be displayed in their color field
+*/
+
+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
+    */
+    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))]];
+
+    /**
+        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
+        @tparam G Number of bits used for the green component
+        @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
+    */
+    using RGBA8    = RGBA<8,8,8,8>;
+
+    /**
+        Type representing a RGB color with 8 bits for the red component, 8 bits for green and 8 bits for blue
+    */
+    using RGB8     = RGB<8,8,8>;
+
+    /**
+        Type representing a RGB color with 5 bits for the red component, 6 bits for green and 5 bits for blue
+    */
+    using RGB565   = RGB<5,6,5>;
+
+    /**
+        Type representing a RGBA color with 4 bits for the red component, 4 bits for green, 4 bits for blue and 4 bits for alpha
+    */
+    using RGB4444  = RGBA<4,4,4,4>;
+
+    /**
+        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 {
+
+        fn format_color(ref auto color) {
+            if (!std::core::has_member(color, "a")) {
+                return std::format("#{0:02X}{1:02X}{2:02X} | rgb({0}, {1}, {2})",
+                                    color.r,
+                                    color.g,
+                                    color.b);
+            } else {
+                return std::format("#{0:02X}{1:02X}{2:02X}{3:02X} | rgba({0}, {1}, {2}, {3})",
+                                    color.r,
+                                    color.g,
+                                    color.b,
+                                    color.a);
+            }
+        };
+
+    }
+
+}

includes/type/float16.pat

@@ -0,0 +1,60 @@
+#pragma once
+
+import std.io;
+import std.math;
+import std.mem;
+
+/*!
+    Type representing a 16 bit half precision floating point number
+*/
+
+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) {
+            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);
+                }
+            } else if (exponent == 0x1F) {
+                result = (sign << 31) | (0xFF << 23) | (mantissa << 13);
+            } else {
+                result = (sign << 31) | ((exponent + (0x7F - 15)) << 23) | (mantissa << 13);
+            }
+
+            std::mem::Reinterpreter<u32, float> converter;
+            converter.from_value = result;
+
+            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

@@ -0,0 +1,50 @@
+#pragma once
+
+import std.io;
+
+/*!
+    Types to deal with UUIDs (Universally Unique Identifiers) / GUIDs (Globally Unique Identifiers) as described in RFC 4122
+*/
+
+namespace auto type {
+
+    /**
+        Type representing a GUID value
+    */
+    struct GUID {
+        u32 time_low;
+        u16 time_mid;
+        u16 time_high_and_version;
+        u8 clock_seq_and_reserved;
+        u8 clock_seq_low;
+        u8 node[6];
+    } [[sealed, format("type::impl::format_guid")]];
+
+    /**
+        Alias name for GUID
+    */
+    using UUID = GUID;
+
+    namespace impl {
+
+        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));
+
+            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

@@ -0,0 +1,67 @@
+#pragma once
+
+import std.io;
+import std.string;
+
+/*!
+    Types used to decode IP addresses
+*/
+
+namespace auto type {
+
+    /**
+        A 4 byte IPv4 Address as described in RFC 791
+    */
+    struct IPv4Address {
+        u8 bytes[4];
+    } [[sealed, format("type::impl::format_ipv4_address")]];
+
+    /**
+        A 16 byte IPv6 Address as described in RFC 8200
+    */
+    struct IPv6Address {
+        be u16 words[8];
+    } [[sealed, format("type::impl::format_ipv6_address")]];
+
+    namespace impl {
+
+        fn format_ipv4_address(IPv4Address address) {
+            return std::format("{}.{}.{}.{}",
+                address.bytes[0],
+                address.bytes[1],
+                address.bytes[2],
+                address.bytes[3]);
+        };
+
+        fn format_ipv6_address(IPv6Address address) {
+            str result;
+
+            bool hadZeros = false;
+            s8 startIndex = -1;
+
+            for (u8 i = 0, i < 8, i += 1) {
+                if (address.words[i] == 0x00 && !hadZeros) {
+                    hadZeros = true;
+                    startIndex = i;
+
+                    while (i < 7) {
+                        if (address.words[i + 1] != 0x00)
+                            break;
+                        i += 1;
+                    }
+
+                    if (startIndex == 0 || i == 7)
+                        result += ":";
+                } else {
+                    result += std::format("{:X}", address.words[i]);
+                }
+
+                result += ":";
+            }
+
+            return std::string::substr(result, 0, std::string::length(result) - 1);
+        };
+
+    }
+
+}

includes/type/leb128.pat

@@ -0,0 +1,72 @@
+#pragma once
+
+import std.io;
+import std.mem;
+
+/*!
+    Types used to decode Little Endian Base 128 numbers used to store large numbers as space efficiently as possible
+*/
+
+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
+    */
+    using uLEB128 = LEB128Base [[format("type::impl::format_uleb128"), transform("type::impl::transform_uleb128")]];
+
+    /**
+        A signed variant of a LEB128 number
+    */
+    using sLEB128 = LEB128Base [[format("type::impl::format_sleb128"), transform("type::impl::transform_sleb128")]];
+
+    /**
+        Legacy alias for uLEB128
+    */
+    using LEB128 = uLEB128;
+
+    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);
+            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

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

includes/type/magic.pat

@@ -0,0 +1,45 @@
+import std.string;
+import std.sys;
+import std.io;
+import std.ctype;
+
+/*!
+    Types used to parse and enforce specific magic numbers
+*/
+
+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 form form \xFF
+        @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
+        @tparam ExpectedValue A string representing the expected value
+    */
+    struct Magic<auto ExpectedValue> {
+        char value[std::string::length(ExpectedValue)];
+        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) {
+            return std::format("\"{}\"", type::escape_bytes(magic.value));
+        };
+    }
+}

includes/type/path.pat

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

includes/type/size.pat

@@ -0,0 +1,72 @@
+import std.io;
+
+/*!
+    Types used to pretty print size values
+*/
+
+namespace auto type {
+
+    /**
+        A generic size type which displays its value in Bytes (or kiB, MiB, GiB, TiB, PiB, EiB if larger)
+        @tparam T Underlying type
+    */
+    using Size<T> = T [[format("type::impl::size_formatter")]];
+
+    /**
+        A 8 bit size type
+    */
+    using Size8   = Size<u8>;
+    /**
+        A 16 bit size type
+    */
+    using Size16  = Size<u16>;
+    /**
+        A 32 bit size type
+    */
+    using Size32  = Size<u32>;
+    /**
+        A 64 bit size type
+    */
+    using Size64  = Size<u64>;
+    /**
+        A 128 bit size type
+    */
+    using Size128 = Size<u128>;
+
+    namespace impl {
+
+        fn size_formatter(u128 size) {
+            double sizeFloat = size;
+            
+            u32 i = 0;
+            while (sizeFloat >= 1024 && i <= 6) {
+                i += 1;
+                sizeFloat /= 1024;
+            }
+            
+            if (i == 0) {
+                if (size == 1)
+                    return std::format("{} Byte", size);
+                else
+                    return std::format("{} Bytes", size);   
+            } else {
+                str result = std::format("{:.3f} ", sizeFloat);
+
+                if (i == 1)
+                    return result + "kiB";
+                else if (i == 2)
+                    return result + "MiB";
+                else if (i == 3)
+                    return result + "GiB";
+                else if (i == 4)
+                    return result + "TiB";
+                else if (i == 5)
+                    return result + "PiB";
+                else
+                    return result + "EiB";
+            }
+        };
+
+    }
+
+}

includes/type/time.pat

@@ -0,0 +1,62 @@
+#pragma once
+
+import std.io;
+import std.time;
+
+/*!
+    Types used to decode various different time formats
+*/
+
+namespace auto type {
+
+    /**
+        A 32 bit Unix time value
+    */
+    using time32_t = u32 [[format("type::impl::format_time_t")]];
+
+    /**
+        Alias name for `time32_t`
+    */
+    using time_t = time32_t;
+
+    /**
+        A 64 bit Unix time value
+    */
+    using time64_t = u64 [[format("type::impl::format_time_t")]];
+
+    /**
+        A DOS Date value
+    */
+    using DOSDate = u16 [[format("type::impl::format_dosdate")]];
+
+    /**
+        A DOS Time value
+    */
+    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) {
+            return std::time::format(std::time::to_utc(value));
+        };
+
+        fn format_dosdate(u16 value) {
+            return std::time::format_dos_date(std::time::to_dos_date(value));
+        };
+
+        fn format_dostime(u16 value) {
+            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

@@ -0,0 +1,66 @@
+#pragma once
+
+/*!
+    Alias types to make it easier to move template definitions over from 010 Editor to ImHex
+*/
+
+// Explicitly don't add these types to the `type` namespace for usability
+// namespace auto type {
+
+    // using char   = s8;
+    using byte      = s8;
+    using CHAR      = s8;
+    using BYTE      = s8;
+
+    using uchar     = u8;
+    using ubyte     = u8;
+    using UCHAR     = u8;
+    using UBYTE     = u8;
+
+
+    using short     = s16;
+    using int16     = s16;
+    using SHORT     = s16;
+    using INT16     = s16;
+    
+    using ushort    = u16;
+    using uint16    = u16;
+    using USHORT    = u16;
+    using UINT16    = u16;
+    using WORD      = u16;
+
+    using int       = s32;
+    using int32     = s32;
+    using long      = s32;
+    using INT       = s32;
+    using INT32     = s32;
+    using LONG      = s32;
+
+    using uint      = u32;
+    using uint32    = u32;
+    using ulong     = u32;
+    using UINT      = u32;
+    using UINT32    = u32;
+    using ULONG     = u32;
+    using DWORD     = u32;
+
+    using int64     = s64;
+    using quad      = s64;
+    using QUAD      = s64;
+    using INT64     = s64;
+    using __int64   = s64;
+
+    using uint64    = u64;
+    using uquad     = u64;
+    using UQUAD     = u64;
+    using UINT64    = u64;
+    using QWORD     = u64;
+    using __uint64  = u64;
+
+    // using float  = float;
+    using FLOAT     = float;
+
+    // using double = double;
+    using DOUBLE    = double;
+
+// }

includes/type/types/c.pat

@@ -0,0 +1,43 @@
+#pragma once
+
+/*!
+    Alias definitions for all C stdint and regular data types
+*/
+
+// Explicitly don't add these types to the `type` namespace for usability
+// namespace auto type {
+
+    using uint8_t       = u8;
+    using uint16_t      = u16;
+    using uint32_t      = u32;
+    using uint64_t      = u64;
+    using __uint64_t    = u64;
+    using uint128_t     = u128;
+    using __uint128_t   = u128;
+
+    using int8_t        = s8;
+    using int16_t       = s16;
+    using int32_t       = s32;
+    using int64_t       = s64;
+    using __int64_t     = s64;
+    using int128_t      = s128;
+    using __int128_t    = s128;
+
+    using size_t        = u64;
+    using ssize_t       = s64;
+
+    using uintptr_t     = u64;
+    using intptr_t      = s64;
+    using ptrdiff_t     = s64;
+
+    // using char       = char;
+    using wchar_t       = char16;
+    using char8_t       = char;
+    using char16_t      = char16;
+    using char32_t      = u32;
+
+    using short         = s16;
+    using int           = s32;
+    using long          = s32;
+
+// }

includes/type/types/linux.pat

@@ -0,0 +1,17 @@
+#pragma once
+
+/*!
+    Various data types used in the Linux Kernel
+*/
+
+// Explicitly don't add these types to the `type` namespace for usability
+// namespace auto type {
+
+    using le16  = le u16;
+    using be16  = be u16;
+    using le32  = le u32;
+    using be32  = be u32;
+    using le64  = le u64;
+    using be64  = be u64;
+
+// }

includes/type/types/rust.pat

@@ -0,0 +1,28 @@
+#pragma once
+
+/*!
+    Alias definitions for Rust's data types
+*/
+
+// Explicitly don't add these types to the `type` namespace for usability
+// namespace auto type {
+
+    // using u8        = u8;
+    // using u16       = u16;
+    // using u32       = u32;
+    // using u64       = u64;
+    // using u128      = u128;
+
+    using i8        = s8;
+    using i16       = s16;
+    using i32       = s32;
+    using i64       = s64;
+    using i128      = s128;
+
+    using f32       = float;
+    using f64       = double;
+
+    using usize     = u64;
+    using isize     = i64;
+
+// }

includes/type/types/win32.pat

@@ -0,0 +1,57 @@
+#pragma once
+
+/*!
+    Alias definitions for various type names used in Windows applications
+*/
+
+// Explicitly don't add these types to the `type` namespace for usability
+// namespace auto type {
+
+    using BYTE      = u8;
+    using WORD      = u16;
+    using DWORD     = u32;
+    using QWORD     = u64;
+    using DWORDLONG = u64;
+    using DWORD32   = u32;
+    using DWORD64   = u64;
+
+    using INT       = s32;
+    using UINT      = u32;
+    using FLOAT     = float;
+    using SHORT     = s16;
+    using USHORT    = u16;
+    using BOOL      = bool;
+    using BOOLEAN   = bool;
+
+    using INT8      = s8;
+    using INT16     = s16;
+    using INT32     = s32;
+    using INT64     = s64;
+    using UINT8     = u8;
+    using UINT16    = u16;
+    using UINT32    = u32;
+    using UINT64    = u64;
+
+    using LONG      = s32;
+    using ULONG     = u32;
+    using LONG32    = s32;
+    using ULONG32   = u32;
+    using LONG64    = s64;
+    using ULONG64   = u64;
+    using LONGLONG  = s64;
+    using ULONGLONG = u64;
+
+    using SIZE_T    = u64;
+    using SSIZE_T   = s64;
+
+    using UCHAR     = u8;
+    using CHAR      = char;
+    using CCHAR     = char;
+
+    using ATOM      = WORD;
+    using PVOID     = SIZE_T;
+    using HANDLE    = PVOID;
+    using HINSTANCE = HANDLE;
+    using HRESULT   = LONG;
+
+// }

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

nodes/caesar.hexnode

@@ -0,0 +1,219 @@
+{
+    "attrs": [
+        76,
+        77,
+        78
+    ],
+    "data": {
+        "nodes": {
+            "links": {
+                "31": {
+                    "from": 54,
+                    "id": 31,
+                    "to": 55
+                },
+                "33": {
+                    "from": 59,
+                    "id": 33,
+                    "to": 56
+                },
+                "34": {
+                    "from": 60,
+                    "id": 34,
+                    "to": 57
+                },
+                "40": {
+                    "from": 68,
+                    "id": 40,
+                    "to": 53
+                },
+                "41": {
+                    "from": 66,
+                    "id": 41,
+                    "to": 69
+                },
+                "42": {
+                    "from": 66,
+                    "id": 42,
+                    "to": 63
+                },
+                "43": {
+                    "from": 58,
+                    "id": 43,
+                    "to": 71
+                },
+                "44": {
+                    "from": 70,
+                    "id": 44,
+                    "to": 72
+                },
+                "45": {
+                    "from": 73,
+                    "id": 45,
+                    "to": 64
+                },
+                "46": {
+                    "from": 65,
+                    "id": 46,
+                    "to": 75
+                }
+            },
+            "nodes": {
+                "19": {
+                    "attrs": [
+                        66
+                    ],
+                    "data": {
+                        "name": "Input",
+                        "type": 2
+                    },
+                    "id": 19,
+                    "name": "Input",
+                    "pos": {
+                        "x": 48.0,
+                        "y": 151.0
+                    },
+                    "type": "hex.builtin.nodes.custom.input"
+                },
+                "20": {
+                    "attrs": [
+                        68
+                    ],
+                    "data": {
+                        "name": "Count",
+                        "type": 0
+                    },
+                    "id": 20,
+                    "name": "Count",
+                    "pos": {
+                        "x": 50.0,
+                        "y": 264.0
+                    },
+                    "type": "hex.builtin.nodes.custom.input"
+                },
+                "21": {
+                    "attrs": [
+                        53,
+                        54
+                    ],
+                    "data": null,
+                    "id": 21,
+                    "name": "hex.builtin.nodes.casting.int_to_buffer.header",
+                    "pos": {
+                        "x": 212.0,
+                        "y": 315.0
+                    },
+                    "type": "hex.builtin.nodes.casting.int_to_buffer"
+                },
+                "22": {
+                    "attrs": [
+                        55,
+                        56,
+                        57,
+                        58
+                    ],
+                    "data": null,
+                    "id": 22,
+                    "name": "hex.builtin.nodes.buffer.slice.header",
+                    "pos": {
+                        "x": 384.0,
+                        "y": 375.0
+                    },
+                    "type": "hex.builtin.nodes.buffer.slice"
+                },
+                "23": {
+                    "attrs": [
+                        59
+                    ],
+                    "data": {
+                        "data": 0
+                    },
+                    "id": 23,
+                    "name": "hex.builtin.nodes.constants.int.header",
+                    "pos": {
+                        "x": 122.0,
+                        "y": 423.0
+                    },
+                    "type": "hex.builtin.nodes.constants.int"
+                },
+                "24": {
+                    "attrs": [
+                        60
+                    ],
+                    "data": {
+                        "data": 1
+                    },
+                    "id": 24,
+                    "name": "hex.builtin.nodes.constants.int.header",
+                    "pos": {
+                        "x": 120.0,
+                        "y": 510.0
+                    },
+                    "type": "hex.builtin.nodes.constants.int"
+                },
+                "25": {
+                    "attrs": [
+                        63,
+                        64,
+                        65
+                    ],
+                    "data": null,
+                    "id": 25,
+                    "name": "hex.builtin.nodes.bitwise.add.header",
+                    "pos": {
+                        "x": 720.0,
+                        "y": 183.0
+                    },
+                    "type": "hex.builtin.nodes.bitwise.add"
+                },
+                "26": {
+                    "attrs": [
+                        69,
+                        70
+                    ],
+                    "data": null,
+                    "id": 26,
+                    "name": "hex.builtin.nodes.buffer.size.header",
+                    "pos": {
+                        "x": 383.0,
+                        "y": 274.0
+                    },
+                    "type": "hex.builtin.nodes.buffer.size"
+                },
+                "27": {
+                    "attrs": [
+                        71,
+                        72,
+                        73
+                    ],
+                    "data": null,
+                    "id": 27,
+                    "name": "hex.builtin.nodes.buffer.repeat.header",
+                    "pos": {
+                        "x": 595.0,
+                        "y": 445.0
+                    },
+                    "type": "hex.builtin.nodes.buffer.repeat"
+                },
+                "28": {
+                    "attrs": [
+                        75
+                    ],
+                    "data": {
+                        "name": "Output",
+                        "type": 2
+                    },
+                    "id": 28,
+                    "name": "Output",
+                    "pos": {
+                        "x": 864.0,
+                        "y": 330.0
+                    },
+                    "type": "hex.builtin.nodes.custom.output"
+                }
+            }
+        }
+    },
+    "name": "Caesar Cipher",
+    "type": "hex.builtin.nodes.custom.custom"
+}

nodes/xor.hexnode

@@ -0,0 +1,223 @@
+{
+    "attrs": [
+        36,
+        37,
+        38
+    ],
+    "data": {
+        "nodes": {
+            "links": {
+                "11": {
+                    "from": 20,
+                    "id": 11,
+                    "to": 22
+                },
+                "13": {
+                    "from": 23,
+                    "id": 13,
+                    "to": 32
+                },
+                "14": {
+                    "from": 17,
+                    "id": 14,
+                    "to": 19
+                },
+                "15": {
+                    "from": 14,
+                    "id": 15,
+                    "to": 15
+                },
+                "16": {
+                    "from": 12,
+                    "id": 16,
+                    "to": 16
+                },
+                "17": {
+                    "from": 9,
+                    "id": 17,
+                    "to": 11
+                },
+                "18": {
+                    "from": 7,
+                    "id": 18,
+                    "to": 10
+                },
+                "19": {
+                    "from": 31,
+                    "id": 19,
+                    "to": 8
+                },
+                "20": {
+                    "from": 30,
+                    "id": 20,
+                    "to": 6
+                },
+                "22": {
+                    "from": 31,
+                    "id": 22,
+                    "to": 18
+                },
+                "23": {
+                    "from": 30,
+                    "id": 23,
+                    "to": 21
+                }
+            },
+            "nodes": {
+                "10": {
+                    "attrs": [
+                        14
+                    ],
+                    "data": {
+                        "data": 1
+                    },
+                    "id": 10,
+                    "name": "hex.builtin.nodes.constants.int.header",
+                    "pos": {
+                        "x": 430.0,
+                        "y": 364.0
+                    },
+                    "type": "hex.builtin.nodes.constants.int"
+                },
+                "11": {
+                    "attrs": [
+                        15,
+                        16,
+                        17
+                    ],
+                    "data": null,
+                    "id": 11,
+                    "name": "hex.builtin.nodes.arithmetic.add.header",
+                    "pos": {
+                        "x": 579.0,
+                        "y": 421.0
+                    },
+                    "type": "hex.builtin.nodes.arithmetic.add"
+                },
+                "12": {
+                    "attrs": [
+                        18,
+                        19,
+                        20
+                    ],
+                    "data": null,
+                    "id": 12,
+                    "name": "hex.builtin.nodes.buffer.repeat.header",
+                    "pos": {
+                        "x": 661.0,
+                        "y": 241.0
+                    },
+                    "type": "hex.builtin.nodes.buffer.repeat"
+                },
+                "13": {
+                    "attrs": [
+                        21,
+                        22,
+                        23
+                    ],
+                    "data": null,
+                    "id": 13,
+                    "name": "hex.builtin.nodes.bitwise.xor.header",
+                    "pos": {
+                        "x": 818.0,
+                        "y": 163.0
+                    },
+                    "type": "hex.builtin.nodes.bitwise.xor"
+                },
+                "14": {
+                    "attrs": [
+                        32
+                    ],
+                    "data": {
+                        "name": "Output",
+                        "type": 2
+                    },
+                    "id": 14,
+                    "name": "Output",
+                    "pos": {
+                        "x": 1000.0,
+                        "y": 432.0
+                    },
+                    "type": "hex.builtin.nodes.custom.output"
+                },
+                "4": {
+                    "attrs": [
+                        30
+                    ],
+                    "data": {
+                        "name": "Input",
+                        "type": 2
+                    },
+                    "id": 4,
+                    "name": "Input",
+                    "pos": {
+                        "x": 82.0,
+                        "y": 139.0
+                    },
+                    "type": "hex.builtin.nodes.custom.input"
+                },
+                "5": {
+                    "attrs": [
+                        31
+                    ],
+                    "data": {
+                        "name": "XOR Pad",
+                        "type": 2
+                    },
+                    "id": 5,
+                    "name": "XOR Pad",
+                    "pos": {
+                        "x": 89.0,
+                        "y": 328.0
+                    },
+                    "type": "hex.builtin.nodes.custom.input"
+                },
+                "6": {
+                    "attrs": [
+                        6,
+                        7
+                    ],
+                    "data": null,
+                    "id": 6,
+                    "name": "hex.builtin.nodes.buffer.size.header",
+                    "pos": {
+                        "x": 269.0,
+                        "y": 403.0
+                    },
+                    "type": "hex.builtin.nodes.buffer.size"
+                },
+                "7": {
+                    "attrs": [
+                        8,
+                        9
+                    ],
+                    "data": null,
+                    "id": 7,
+                    "name": "hex.builtin.nodes.buffer.size.header",
+                    "pos": {
+                        "x": 267.0,
+                        "y": 486.0
+                    },
+                    "type": "hex.builtin.nodes.buffer.size"
+                },
+                "8": {
+                    "attrs": [
+                        10,
+                        11,
+                        12
+                    ],
+                    "data": null,
+                    "id": 8,
+                    "name": "hex.builtin.nodes.arithmetic.div.header",
+                    "pos": {
+                        "x": 409.0,
+                        "y": 465.0
+                    },
+                    "type": "hex.builtin.nodes.arithmetic.div"
+                }
+            }
+        }
+    },
+    "name": "XOR Pad",
+    "type": "hex.builtin.nodes.custom.custom"
+}