patterns/tar: Fixed minor typo (#230)

changes "if" to "id"

.gitattributes

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

README.md

@@ -78,6 +78,7 @@ Everything will immediately show up in ImHex's Content Store and gets bundled wi
 | NBT | | [`patterns/nbt.hexpat`](patterns/nbt.hexpat) | Minecraft NBT format |
 | NE   | | [`patterns/ne.hexpat`](patterns/ne.hexpat) | NE header and Standard NE fields |
 | nes   | | [`patterns/nes.hexpat`](patterns/nes.hexpat) | .nes file format |
+| NotepadWindowState | | [`patterns/notepad-windowstate.hexpat`](patterns/notepad-windowstate.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 |
@@ -94,12 +95,15 @@ Everything will immediately show up in ImHex's Content Store and gets bundled wi
 | PYC | | [`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 |
+| 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 |
 | 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 |
 | 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 |
+| SWF | |[`patterns/swf.hexpat`](patterns/swf.hexpat) | Shockwave Flash file format |
 | TAR | `application/x-tar` | [`patterns/tar.hexpat`](patterns/tar.hexpat) | Tar file format |
 | 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 |
@@ -115,6 +119,7 @@ Everything will immediately show up in ImHex's Content Store and gets bundled wi
 | XBEH | `audio/x-xbox-executable` | [`patterns/xbeh.hexpat`](patterns/xbeh.hexpat) | Xbox executable |
 | XCI | | [`patterns/xci.hexpat`](patterns/xci.hexpat) | Nintendo Switch XCI cardridge ROM |
 | Xilinx BIT | | [`patterns/xilinx_bit.hexpat`](patterns/xilinx_bit.hexpat) | Xilinx FPGA Bitstreams |
+| Xilinx Bootgen | | [`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 |
@@ -167,6 +172,7 @@ Everything will immediately show up in ImHex's Content Store and gets bundled wi
 | ASCII+OEM | [`encodings/ascii_oem.tbl`](encodings/ascii_oem.tbl) | ASCII encoding with Windows OEM characters |
 | Baltic ISO | [`encodings/baltic_iso.tbl`](encodings/baltic_iso.tbl) | Baltic ISO encoding |
 | Baltic Windows | [`encodings/baltic_windows.tbl`](encodings/baltic_windows.tbl) | Baltic Windows encoding |
+| Big5 (Traditional Chinese) | [`encodings/big5.tbl`](encodings/big5.tbl) | Big5 encoding for Traditional Chinese |
 | Cyrillic ISO | [`encodings/cyrillic_iso.tbl`](encodings/cyrillic_iso.tbl) | Cyrillic ISO encoding |
 | Cyrillic Windows | [`encodings/cyrillic_windows.tbl`](encodings/cyrillic_windows.tbl) | Cyrillic Windows encoding |
 | Cyrillic KOI8-R | [`encodings/cyrillic_koi8_r.tbl`](encodings/cyrillic_koi8_r.tbl) | Cyrillic KOI8-R encoding (Russian Characters) |
@@ -194,6 +200,7 @@ Everything will immediately show up in ImHex's Content Store and gets bundled wi
 | 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 |
+> import custom encoding from File -> Import... -> Custome Encoding File
 
 ### Data Processor Nodes
 | Name | Path | Description |

includes/hex/core.pat

@@ -1,12 +1,12 @@
 #pragma once
 
-#include <hex/impl/imhex_check.pat>
+import hex.impl.imhex_check;
 
 /*!
     Core intrinsic functions to interact with the ImHex Hex Editor
 */
 
-namespace hex::core {
+namespace auto hex::core {
 
     /**
         A type representing a selection in the hex editor

includes/hex/dec.pat

@@ -1,12 +1,14 @@
 #pragma once
 
-#include <hex/impl/imhex_check.pat>
+import hex.impl.imhex_check;
+
+import std.mem;
 
 /*!
     Library to allow decoding of more complex values
 */
 
-namespace hex::dec {
+namespace auto hex::dec {
 
     /**
         Demangles a mangled name into a human readable name
@@ -17,4 +19,46 @@ namespace hex::dec {
         return builtin::hex::dec::demangle(mangled_name);
     };
 
+
+    /**
+        Decompresses the bytes of a pattern into a section using the zlib algorithm
+        @param pattern The pattern whose bytes should be decompressed
+        @param section The section to decompress the data into
+        @param window_size The window size passed to zlib
+        @return 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);
+    };
+    
 }

includes/hex/http.pat

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

includes/hex/provider.pat

@@ -1,12 +1,12 @@
 #pragma once
 
-#include <hex/impl/imhex_check.pat>
+import hex.impl.imhex_check;
 
 /*!
     Library to interact with the currently loaded provider.
 */
 
-namespace hex::prv {
+namespace auto hex::prv {
     
     
     /**

includes/hex/type/mangled.pat

@@ -1,16 +1,16 @@
 #pragma once
 
-#include <std/io.pat>
-#include <std/mem.pat>
+import std.io;
+import std.mem;
 
-#include <hex/impl/imhex_check.pat>
-#include <hex/dec.pat>
+import hex.impl.imhex_check;
+import hex.dec;
 
 /*!
     Types to automatically decode mangled names
 */
 
-namespace hex::type {
+namespace auto hex::type {
 	
     /**
         A mangled name string that gets demangled when displayed

includes/std/array.pat

@@ -1,13 +1,13 @@
 #pragma once
 
-#include <std/sys.pat>
+import std.sys;
 
 /*!
     The array library contains a helper type to make it easier to create multi-dimensional arrays
     and pass arrays to functions as parameters.
 */
 
-namespace std {
+namespace auto std {
 
     /**
         Simple one dimensional array wrapper

includes/std/bit.pat

@@ -1,12 +1,12 @@
 #pragma once
 
-#include <std/limits.pat>
+import std.limits;
 
 /*!
 	This library contains various helper functions for common bit operations.
 */
 
-namespace std::bit {
+namespace auto std::bit {
 
 	/**
 		Calculates the number of 1 bits in a given number

includes/std/core.pat

@@ -1,13 +1,13 @@
 #pragma once
 
-#include <std/mem.pat>
+import std.mem;
 
 /*!
     The core library contains intrinsics and "compiler magic" functions that
     get extra help from the runtime to fulfill their purpose.
 */
 
-namespace std::core {
+namespace auto std::core {
 
     /**
         The layout order of each field after byte-endianness has been handled.
@@ -38,12 +38,20 @@ namespace std::core {
     };
 
     /**
-        Returns the first parameter of the attribute of a pattern if it has one
+        Returns the nth parameter of the attribute of a pattern if it has one
         @param pattern The pattern to check
         @param attribute The attribute's name to query
+        @param [index] The parameter index of the attribute to return. Defaults to 0
+    */
+    fn get_attribute_argument(ref auto pattern, str attribute, u32 index = 0) {
+        return builtin::std::core::get_attribute_argument(pattern, attribute, index);
+    };
+
+    /**
+        @warning Removed in 1.27.0
     */
     fn get_attribute_value(ref auto pattern, str attribute) {
-        return builtin::std::core::get_attribute_value(pattern, attribute);
+        builtin::std::error("`std::core::get_attribute_value(pattern, attribute)` has been removed.\nUse `std::core::get_attribute_argument(pattern, attribute, [index])` instead.");
     };
 
 
@@ -146,4 +154,14 @@ namespace std::core {
     fn set_display_name(ref auto pattern, str name) {
         builtin::std::core::set_display_name(pattern, name);
     }; 
+
+
+    /**
+        Changes the comment attached to a pattern
+        @param pattern The pattern to modify
+        @param name The new comment of the pattern
+    */
+    fn set_pattern_comment(ref auto pattern, str comment) {
+        builtin::std::core::set_pattern_comment(pattern, name);
+    }; 
 }

includes/std/ctype.pat

@@ -5,7 +5,7 @@
     of ASCII characters.
 */
 
-namespace std::ctype {
+namespace auto std::ctype {
 
     /**
         Checks if the given character `c` is a digit between '0' and '9'

includes/std/file.pat

@@ -7,7 +7,7 @@
 	**These functions are considered dangerous and require the user to manually permit them**
 */
 
-namespace std::file {
+namespace auto std::file {
 
 	/**
         A handle representing a file that has been opened

includes/std/fxpt.pat

@@ -4,7 +4,7 @@
 	Library for doing arithmetic with fixed point numbers and converting them from/to floating point numbers.
 */
 
-namespace std::fxpt {
+namespace auto std::fxpt {
 
 	/**
 		A fixed point value

includes/std/hash.pat

@@ -4,7 +4,7 @@
     The hash library contains various data hash functions
 */
 
-namespace std::hash {
+namespace auto std::hash {
 
     /**
         Calculates the CRC32 hash of the bytes inside of a given pattern

includes/std/io.pat

@@ -4,7 +4,7 @@
     The IO library allows formatting strings and outputting text to the console
 */
 
-namespace std {
+namespace auto std {
 
     /**
         Formats the given arguments using the format string and prints the result to the console

includes/std/limits.pat

@@ -4,7 +4,7 @@
 	Library to calculate the minimum and maximum values that fit into a given data type
 */
 
-namespace std::limits {
+namespace auto std::limits {
 	
 	/**
 		Returns the minimum value that can be stored in a `u8`.

includes/std/math.pat

@@ -1,12 +1,12 @@
 #pragma once
 
-#include <std/mem.pat>
+import std.mem;
 
 /*!
 	Library containing more advanced mathematical operations.
 */
 
-namespace std::math {
+namespace auto std::math {
 
 	/**
 		Compares the values `a` and `b` with each other and returns the smaller of the two
@@ -328,9 +328,9 @@ namespace std::math {
 		@param start Start address
 		@param end End address
 		@param valueSize Size of each value in bytes
-		@param section Section to use
-		@param operation Operation to use
-		@param endian Endianness to use
+		@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) {

includes/std/mem.pat

@@ -4,7 +4,7 @@
     Library for doing raw memory accesses and other low-level operations.
 */
 
-namespace std::mem {
+namespace auto std::mem {
 
     namespace impl {
 
@@ -104,7 +104,7 @@ namespace std::mem {
         Reads a unsigned value from the memory
         @param address The address to read from
         @param size The size of the value to read
-        @param endian The endianess of the value to read
+        @param [endian] The endianess of the value to read. Defaults to native
         @return The value read
     */
     fn read_unsigned(u128 address, u8 size, Endian endian = Endian::Native) {
@@ -115,7 +115,7 @@ namespace std::mem {
         Reads a signed value from the memory
         @param address The address to read from
         @param size The size of the value to read
-        @param endian The endianess of the value to read
+        @param [endian] The endianess of the value to read. Defaults to native
         @return The value read
     */
     fn read_signed(u128 address, u8 size, Endian endian = Endian::Native) {
@@ -128,7 +128,7 @@ namespace std::mem {
         @param size The size of the value to read
         @return The value read
     */
-    fn read_string(u128 address, u8 size) {
+    fn read_string(u128 address, u128 size) {
         return builtin::std::mem::read_string(address, size);
     };
 

includes/std/ptr.pat

@@ -1,13 +1,13 @@
 #pragma once
 
-#include <std/mem.pat>
+import std.mem;
 
 /*!
     The Pointer library contains helper functions to deal with pointer types.
     The `relative_to` functions are meant to be used with the `[[pointer_base]]` attribute
 */
 
-namespace std::ptr {
+namespace auto std::ptr {
 
     /**
         Use the offset of the current pointer as start address

includes/std/random.pat

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

@@ -1,12 +1,12 @@
 #pragma once
 
-#include <std/io.pat>
+import std.io;
 
 /*!
 	Libray to interact with strings.
 */
 
-namespace std::string {
+namespace auto std::string {
 
 	/**
 	    Base type for sized strings. Represents a string with its size preceeding it.

includes/std/sys.pat

@@ -1,12 +1,12 @@
 #pragma once
 
-#include <std/io.pat>
+import std.io;
 
 /*!
     Basic helper functions
 */
 
-namespace std {
+namespace auto std {
 
     /**
         Asserts that a given value is true. If it's not, abort evaluation and print the given message to the console

includes/std/time.pat

@@ -1,12 +1,12 @@
 #pragma once
 
-#include <std/io.pat>
+import std.io;
 
 /*!
 	Library to handle time and date related operations.
 */
 
-namespace std::time {
+namespace auto std::time {
 
 	/**
 		A structured representation of a time and date.
@@ -113,7 +113,7 @@ namespace std::time {
 
 	/**
 		Queries the current time in the specified time zone.
-		@param time_zone The time zone to query.
+		@param [time_zone] The time zone to query. Defaults to local.
 		@return The current time in the specified time zone.
 	*/
 	fn now(TimeZone time_zone = TimeZone::Local) {
@@ -167,7 +167,7 @@ namespace std::time {
 	/**
 		Formats a time according to the specified format string.
 		@param time The time to format.
-		@param format_string The format string to use.
+		@param [format_string] The format string to use. Defaults to "%c".
 		@return The formatted time.
 	*/
 	fn format(Time time, str format_string = "%c") {
@@ -180,7 +180,7 @@ namespace std::time {
 	/**
 		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.
+		@param [format_string] The format string to use. Defaults to "{}/{}/{}".
 		@return The formatted DOS date.
 	*/
 	fn format_dos_date(DOSDate date, str format_string = "{}/{}/{}") {
@@ -190,7 +190,7 @@ namespace std::time {
 	/**
 		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.
+		@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}") {

includes/type/base.pat

@@ -1,14 +1,14 @@
 #pragma once
 
-#include <std/io.pat>
-#include <std/math.pat>
+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 type {
+namespace auto type {
     
     /**
         Integer type representing a Hexadecimal value. Displays its value in hexadecimal format.

includes/type/base64.pat

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

includes/type/bcd.pat

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

includes/type/byte.pat

@@ -1,12 +1,12 @@
 #pragma once
 
-#include <std/io.pat>
+import std.io;
 
 /*!
     Types to display single bytes using various different representations
 */
 
-namespace type {
+namespace auto type {
     
     /**
         Type visualizing the value of each individual bit

includes/type/color.pat

@@ -1,13 +1,13 @@
 #pragma once
 
-#include <std/io.pat>
-#include <std/core.pat>
+import std.io;
+import std.core;
 
 /*!
     Types representing RGB or RGBA colors. The decoded color will be displayed in their color field
 */
 
-namespace type {
+namespace auto type {
 
     /**
         Type representing a generic RGBA color with a variable number of bits for each color

includes/type/float16.pat

@@ -1,14 +1,14 @@
 #pragma once
 
-#include <std/io.pat>
-#include <std/math.pat>
-#include <std/mem.pat>
+import std.io;
+import std.math;
+import std.mem;
 
 /*!
     Type representing a 16 bit half precision floating point number
 */
 
-namespace type {
+namespace auto type {
     
     /**
         Type representing a 16 bit half precision floating point number

includes/type/guid.pat

@@ -1,12 +1,12 @@
 #pragma once
 
-#include <std/io.pat>
+import std.io;
 
 /*!
 	Types to deal with UUIDs (Universally Unique Identifiers) / GUIDs (Globally Unique Identifiers) as described in RFC 4122
 */
 
-namespace type {
+namespace auto type {
 
 	/**
 		Type representing a GUID value

includes/type/ip.pat

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

includes/type/leb128.pat

@@ -1,13 +1,13 @@
 #pragma once
 
-#include <std/io.pat>
-#include <std/mem.pat>
+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 type {
+namespace auto type {
 	
 	/**
 		Base LEB128 type. Use `uLEB128` and `sLEB128` instead.

includes/type/mac.pat

@@ -1,12 +1,12 @@
 #pragma once
 
-#include <std/io.pat>
+import std.io;
 
 /*!
 	Types used to decode MAC Addresses
 */
 
-namespace type {
+namespace auto type {
 
 	/**
 		A MAC Address as used in the Internet Protocol

includes/type/magic.pat

@@ -1,38 +1,43 @@
-#include <std/string.pat>
-#include <std/sys.pat>
-#include <std/io.pat>
-#include <std/ctype.pat>
+import std.string;
+import std.sys;
+import std.io;
+import std.ctype;
 
 /*!
     Types used to parse and enforce specific magic numbers
 */
 
-namespace type {
+namespace auto type
+{
+    fn fm(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 std::format("\"{}\"", 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> {
+    struct Magic<auto ExpectedValue>
+    {
         char value[std::string::length(ExpectedValue)];
-        std::assert(value == ExpectedValue, std::format("Invalid magic value! Expected \"{}\", got \"{}\".", ExpectedValue, value));
+        std::assert_warn(value == ExpectedValue, std::format("Invalid magic value! Expected {}, got {} at position 0x{:X}", type::fm(ExpectedValue), type::fm(value), $ - std::string::length(ExpectedValue)));
     } [[sealed, format("type::impl::format_magic")]];
-    
-    namespace impl {
-    
-        fn format_magic(ref auto magic) {
-            str result;
-            for (u32 i = 0, i < sizeof(magic.value), i += 1) {
-                char c = magic.value[i];
-
-                if (std::ctype::isprint(c))
-                    result += c;
-                else
-                    result += std::format("\\x{:02X}", u8(c));
-            }
-            return std::format("\"{}\"", result);
+    namespace impl
+    {
+        fn format_magic(ref auto magic)
+        {
+            return type::fm(magic.value);
         };
-        
     }
-
 }

includes/type/path.pat

@@ -1,10 +1,10 @@
-#include <std/mem.pat>
+import std.mem;
 
 /*!
 	Types dealing with various kinds of resource paths
 */
 
-namespace type {
+namespace auto type {
 
 	/**
 		Type representing a single path segment. Use the `Path` type instead of using this on its own

includes/type/size.pat

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

includes/type/time.pat

@@ -1,13 +1,13 @@
 #pragma once
 
-#include <std/io.pat>
-#include <std/time.pat>
+import std.io;
+import std.time;
 
 /*!
     Types used to decode various different time formats
 */
 
-namespace type {
+namespace auto type {
 
     /**
         A 32 bit Unix time value

includes/type/types/010.pat

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

includes/type/types/c.pat

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

includes/type/types/linux.pat

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

includes/type/types/rust.pat

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

includes/type/types/win32.pat

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

patterns/3ds.hexpat

@@ -1,8 +1,8 @@
 #pragma author WerWolv
 #pragma description Autodesk 3DS Max Model file
 
-#include <std/io.pat>
-#include <type/base.pat>
+import std.io;
+import type.base;
 
 #pragma MIME image/x-3ds
 

patterns/7z.hexpat

@@ -1,8 +1,8 @@
 #pragma description 7z File Format
 
-#include <std/io.pat> 
-#include <std/mem.pat> 
-#include <std/math.pat> 
+import std.io; 
+import std.mem; 
+import std.math; 
 
 
 enum Type:u8{ 

patterns/Crashlvl.hexpat

@@ -2,9 +2,9 @@
 #pragma description Crash Bandicoot - Back in Time (fan game) User created level format
 // Supports all versions till 0.94c, newer versions might be compatible!
 
-#include <type/magic.pat>
-#include <std/string.pat>
-#include <std/array.pat>
+import type.magic;
+import std.string;
+import std.array;
 
 
 struct Header {

patterns/adts.hexpat

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

patterns/afe2.hexpat

@@ -3,8 +3,8 @@
 
 #pragma endian little
 
-#include <std/io.pat>
-#include <std/sys.pat>
+import std.io;
+import std.sys;
 
 #define ATMOSPHERE_REBOOT_TO_FATAL_MAGIC   	"AFE2"
 #define ATMOSPHERE_REBOOT_TO_FATAL_MAGIC_1 	"AFE1"

patterns/ar.hexpat

@@ -3,9 +3,9 @@
 
 #pragma MIME application/x-archive
 
-#include <std/string.pat>
-#include <std/mem.pat>
-#include <std/sys.pat>
+import std.string;
+import std.mem;
+import std.sys;
 
 struct ARFile {
 	char file_name[16];

patterns/arm_cm_vtor.hexpat

@@ -3,8 +3,8 @@
 
 #pragma endian little
 
-#include <std/io.pat>
-#include <std/mem.pat>
+import std.io;
+import std.mem;
 
 #define VTOR	0x00000000
 #define EXTERNAL_INTERRUPT_COUNT	64

patterns/bencode.hexpat

@@ -3,9 +3,9 @@
 
 #pragma MIME application/x-bittorrent
 
-#include <std/ctype.pat>
-#include <std/mem.pat>
-#include <std/string.pat>
+import std.ctype;
+import std.mem;
+import std.string;
 
 namespace bencode {
 	

patterns/bgcode.hexpat

@@ -0,0 +1,80 @@
+#pragma author Shadlock0133 (aka Aurora)
+#pragma description Binary G-Code from Prusa
+
+#include <type/magic.pat>
+#include <std/mem.pat>
+
+enum ChecksumType : u16 {
+    None,
+    CRC32,
+};
+
+enum BlockType : u16 {
+    FileMetadata,
+    GCode,
+    SlicerMetadata,
+    PrinterMetadata,
+    PrintMetadata,
+    Thumbnail,
+};
+
+enum Compression : u16 {
+    None,
+    Deflate,
+    Heatshrink11_4,
+    Heatshrink12_4,
+};
+
+enum Encoding : u16 {
+    Ini,
+};
+
+enum ImageFormat : u16 {
+    Png,
+    Jpg,
+    Qoi,
+};
+
+struct Header {
+    type::Magic<"GCDE"> magic;
+    u32 version;
+    ChecksumType checksum_type;
+};
+
+Header header @ 0;
+std::assert(header.version == 1, "only version 1 supported");
+    
+struct Block {
+    BlockType type;
+    Compression compression;
+    u32 uncompressed_size;
+    auto size = uncompressed_size;
+    if (compression != Compression::None) {
+        u32 compressed_size;
+        size = compressed_size;
+    }
+    match (type) {
+        (BlockType::FileMetadata
+        | BlockType::PrinterMetadata
+        | BlockType::PrintMetadata
+        | BlockType::SlicerMetadata): {
+            Encoding encoding;
+        }
+        (BlockType::Thumbnail): {
+            ImageFormat image_format;
+            u16 width;
+            u16 height;
+        }
+        (BlockType::GCode): {
+            u16;
+        }
+        (_): { std::assert(false, "unknown type"); }
+    }
+    u8 data[size];
+    match (header.checksum_type) {
+        (ChecksumType::None): {}
+        (ChecksumType::CRC32): { u32 checksum; }
+    }
+};
+
+Block blocks[while(!std::mem::eof())] @ $;

patterns/bmp.hexpat

@@ -2,7 +2,7 @@
 
 #pragma MIME image/bmp
 #pragma endian little
-#include <std/mem.pat>
+import std.mem;
 
 struct BitmapFileHeader {
 	u8 bfType[2];

patterns/bplist.hexpat

@@ -1,7 +1,7 @@
-#include <std/math.pat>
-#include <std/core.pat>
-#include <type/magic.pat>
-#include <type/time.pat>
+import std.math;
+import std.core;
+import type.magic;
+import type.time;
 
 using CFBinaryPlistObject;
 

patterns/bson.hexpat

@@ -3,8 +3,8 @@
 
 #pragma MIME application/bson
 
-#include <std/mem.pat>
-#include <type/time.pat>
+import std.mem;
+import type.time;
 
 enum Type : u8 {
     Double              = 0x01,

patterns/bsp_goldsrc.hexpat

@@ -1,8 +1,8 @@
 #pragma description GoldSrc engine maps format (used in Half-Life 1)
 
-#include <std/ptr.pat>
-#include <std/mem.pat>
-#include <std/sys.pat>
+import std.ptr;
+import std.mem;
+import std.sys;
 
 #pragma endian little
 

patterns/chm.hexpat

@@ -1,11 +1,11 @@
 #pragma author WerWolv
 #pragma description Windows HtmlHelp Data (ITSF / CHM)
 
-#include <type/magic.pat>
-#include <type/size.pat>
-#include <type/guid.pat>
-#include <type/leb128.pat>
-#include <std/sys.pat>
+import type.magic;
+import type.size;
+import type.guid;
+import type.leb128;
+import std.sys;
 
 enum WindowsLanguageId : u32 {
     Arabic_SaudiArabia                          = 0x401,

patterns/coff.hexpat

@@ -3,8 +3,8 @@
 
 #pragma MIME application/x-coff
 
-#include <type/time.pat>
-#include <type/size.pat>
+import type.time;
+import type.size;
 
 enum Machine : u16 {
     Unknown     = 0x0000,

patterns/cpio.hexpat

@@ -1,12 +1,12 @@
 #pragma author WerWolv
 #pragma description Old Binary CPIO Format
 
-#include <type/base.pat>
+import type.base;
 
-#include <std/time.pat>
-#include <std/core.pat>
-#include <std/sys.pat>
-#include <std/mem.pat>
+import std.time;
+import std.core;
+import std.sys;
+import std.mem;
 
 #pragma MIME application/x-cpio
 

patterns/dex.hexpat

@@ -1,6 +1,6 @@
 #pragma description Dalvik EXecutable Format
 
-#include <type/leb128.pat>
+import type.leb128;
 
 struct header_item {
     u8 magic[8];

patterns/dicom.hexpat

@@ -3,12 +3,12 @@
 #pragma MIME application/dicom
 #pragma endian little
 
-#include <std/core.pat>
-#include <std/io.pat>
-#include <std/mem.pat>
-#include <std/string.pat>
-#include <std/sys.pat>
-#include <type/magic.pat>
+import std.core;
+import std.io;
+import std.mem;
+import std.string;
+import std.sys;
+import type.magic;
 
 u32 UNDEFINED_LENGTH = 0xffffffff;
 

patterns/dmg.hexpat

@@ -2,10 +2,10 @@
 
 #pragma endian big
 
-#include <type/magic.pat>
-#include <type/size.pat>
-#include <type/guid.pat>
-#include <std/mem.pat>
+import type.magic;
+import type.size;
+import type.guid;
+import std.mem;
 
 // Parse DMG Structure per http://newosxbook.com/DMG.html
 //

patterns/dsstore.hexpat

@@ -2,7 +2,7 @@
 
 // Apple macOS .DS_Store format
 #pragma endian big
-#include <std/io.pat>
+import std.io;
 
 struct RecordEntry {
   u32 length;

patterns/elf.hexpat

@@ -7,9 +7,9 @@
 #pragma MIME application/x-object
 #pragma MIME application/x-sharedlib
 
-#include <std/core.pat>
-#include <std/io.pat>
-#include <std/mem.pat>
+import std.core;
+import std.io;
+import std.mem;
 
 using BitfieldOrder = std::core::BitfieldOrder;
 

patterns/fdt.hexpat

@@ -3,12 +3,12 @@
 
 #pragma endian big
 
-#include <std/sys.pat>
-#include <std/io.pat>
-#include <std/core.pat>
+import std.sys;
+import std.io;
+import std.core;
 
-#include <type/magic.pat>
-#include <type/size.pat>
+import type.magic;
+import type.size;
 
 // These are used in order for the children to be able to find strings
 u64 fdt_addr;

patterns/flac.hexpat

@@ -1,9 +1,9 @@
 #pragma author WerWolv
 #pragma description Free Lossless Audio Codec, FLAC Audio Format
 
-#include <std/sys.pat>
-#include <std/core.pat>
-#include <std/io.pat>
+import std.sys;
+import std.core;
+import std.io;
 
 #pragma endian big
 

patterns/fs.hexpat

@@ -1,7 +1,7 @@
 #pragma author WerWolv
 #pragma description Drive File System
 
-#include <std/io.pat>
+import std.io;
 
 struct DiskTimeStamp {
 	u8 seconds, minutes, hours;

patterns/gb.hexpat

@@ -3,9 +3,9 @@
 
 #pragma MIME application/x-gameboy-rom
 
-#include <type/size.pat>
-#include <std/string.pat>
-#include <std/mem.pat>
+import type.size;
+import std.string;
+import std.mem;
 
 bool uppercaseROMFeatures in;
 bool brandedROMFeatures in;

patterns/gif.hexpat

@@ -13,13 +13,13 @@
 #define EXTENSION_INTRODUCER_MAGIC 0x21
 #define GIF_TRAILER_MAGIC 0x3B
 
-#include <std/io.pat>
-#include <std/core.pat>
-#include <std/mem.pat>
-#include <std/string.pat>
-#include <std/math.pat>
+import std.io;
+import std.core;
+import std.mem;
+import std.string;
+import std.math;
 
-#include <type/magic.pat>
+import type.magic;
 
 bitfield GCT_Flags {
     size : 3 [[comment("physical size = 2^(flags.size + 1)")]];

patterns/gltf.hexpat

@@ -22,8 +22,8 @@
  * SOFTWARE.
  */
 
-#include <std/mem.pat>
-#include <std/io.pat>
+import std.mem;
+import std.io;
 
 /**
  * @brief The glTF magic section.

patterns/gzip.hexpat

@@ -3,10 +3,10 @@
 
 #pragma MIME application/gzip
 
-#include <type/time.pat>
-#include <type/size.pat>
-#include <std/core.pat>
-#include <std/mem.pat>
+import type.time;
+import type.size;
+import std.core;
+import std.mem;
 
 using BitfieldOrder = std::core::BitfieldOrder;
 

patterns/hinf_bitmap.hexpat

@@ -1,6 +1,6 @@
-#include <std/mem.pat>
-#include <std/io.pat>
-#include <std/string.pat>
+import std.mem;
+import std.io;
+import std.string;
 
 struct Header {
     u32 magic;                     

patterns/hinf_luas.hexpat

@@ -1,10 +1,10 @@
 #pragma author Surasia
 #pragma description Halo Infinite HavokScript 5.1 "luas" file
 
-#include <std/io.pat>
-#include <std/mem.pat>
-#include <std/core.pat>
-#include <std/string.pat>
+import std.io;
+import std.mem;
+import std.core;
+import std.string;
 
 struct String32 {
     s32 length;

patterns/ico.hexpat

@@ -3,7 +3,7 @@
 
 #pragma endian little
 
-#include <std/sys.pat>
+import std.sys;
 
 #pragma MIME image/vnd.microsoft.icon
 #pragma MIME image/x-icon

patterns/id3.hexpat

@@ -2,7 +2,7 @@
 
 #pragma MIME audio/mpeg
 
-#include <std/mem.pat>
+import std.mem;
 
 namespace v1 {
 

patterns/intel_hex.hexpat

@@ -8,7 +8,7 @@
 */
 #pragma endian big
 
-#include <std/mem.pat>
+import std.mem;
 
 enum FileType: u16 {
 	Data = 0x3030,

patterns/ip.hexpat

@@ -3,8 +3,8 @@
 
  #pragma endian big
 
-#include <std/sys.pat>
-#include <std/io.pat>
+import std.sys;
+import std.io;
 
 struct MAC {
 	u8 octets[6];

patterns/ips.hexpat

@@ -3,8 +3,8 @@
 
 #pragma endian big
 
-#include <std/mem.pat>
-#include <std/string.pat>
+import std.mem;
+import std.string;
 
 struct Hunk {
 	u24 offset;

patterns/iso.hexpat

@@ -2,7 +2,7 @@
 
 #pragma endian little
 
-#include <std/io.pat>
+import std.io;
 
 enum VolumeDescriptorTypes : u8 {
   BootRecord,

patterns/java_class.hexpat

@@ -5,11 +5,11 @@
 #pragma pattern_limit 100000000
 #pragma MIME application/x-java-applet
 
-#include <std/string.pat>
-#include <std/math.pat>
-#include <std/core.pat>
-#include <std/io.pat>
-#include <std/sys.pat>
+import std.string;
+import std.math;
+import std.core;
+import std.io;
+import std.sys;
 
 using BitfieldOrder = std::core::BitfieldOrder;
 

patterns/jpeg.hexpat

@@ -1,9 +1,9 @@
 #pragma author WerWolv
 #pragma description JPEG Image Format
 
-#include <std/io.pat>
-#include <std/mem.pat>
-#include <type/magic.pat>
+import std.io;
+import std.mem;
+import type.magic;
 #pragma endian big
 
 #pragma MIME image/jpeg

patterns/lnk.hexpat

@@ -3,9 +3,9 @@
 
 #pragma MIME application/x-ms-shortcut
 
-#include <std/core.pat>
-#include <type/guid.pat>
-#include <type/size.pat>
+import std.core;
+import type.guid;
+import type.size;
 
 using BitfieldOrder = std::core::BitfieldOrder;
 

patterns/lua54.hexpat

@@ -1,7 +1,7 @@
 #pragma description Lua 5.4 bytecode
 
-#include <std/io.pat>
-#include <std/mem.pat>
+import std.io;
+import std.mem;
 
 namespace impl {
 

patterns/macho.hexpat

@@ -3,7 +3,7 @@
 
 #pragma MIME application/x-mach-binary
 
-#include <type/size.pat>
+import type.size;
 
 enum Magic : u32 {
     _32BitMagic = 0xFEEDFACE,

patterns/max_v104.hexpat

@@ -1,7 +1,7 @@
 #pragma description Mechanized Assault and Exploration v1.04 (strategy game) save file format
 
-#include <std/sys.pat>
-#include <std/mem.pat>
+import std.sys;
+import std.mem;
 
 #pragma array_limit 12544
 #pragma pattern_limit 2000000

patterns/midi.hexpat

@@ -1,6 +1,6 @@
 #pragma description MIDI header, event fields provided
 
-#include <std/core.pat>
+import std.core;
 
 #pragma MIME audio/midi
 #pragma endian big

patterns/minidump.hexpat

@@ -3,9 +3,9 @@
 
 #pragma MIME application/x-dmp
 
-#include <type/time.pat>
-#include <type/types/win32.pat>
-#include <type/size.pat>
+import type.time;
+import type.types.win32;
+import type.size;
 
 using RVA = ULONG32;
 using RVA64 = ULONG64;

patterns/mp4.hexpat

@@ -6,9 +6,9 @@
 #pragma MIME video/mp4
 #pragma MIME application/mp4
 
-#include <std/io.pat>
-#include <std/mem.pat>
-#include <std/string.pat>
+import std.io;
+import std.mem;
+import std.string;
 
 fn to_string(auto var) {
     return str(var);

patterns/nacp.hexpat

@@ -3,8 +3,8 @@
 
 #pragma endian little
 
-#include <std/sys.pat>
-#include <std/io.pat>
+import std.sys;
+import std.io;
 
 struct ApplicationTitle {
 	char name[0x200];

patterns/nbt.hexpat

@@ -1,7 +1,7 @@
 #pragma author WerWolv
 #pragma description Minecraft NBT format
 
-#include <std/sys.pat>
+import std.sys;
 
 #pragma endian big
 

patterns/ne.hexpat

@@ -1,6 +1,6 @@
 #pragma description NE header and Standard NE fields
 
-#include <std/mem.pat>
+import std.mem;
 
 struct DOSHeader {
     char signature[2];

patterns/nes.hexpat

@@ -1,8 +1,8 @@
 #pragma author gmestanley
 #pragma description .nes file format
 
-#include <std/mem.pat>
-#include <std/string.pat>
+import std.mem;
+import std.string;
 
 bitfield iNES07Flags {
 	mirroringIsVertical : 1;

patterns/notepadwindowstate.hexpat

@@ -0,0 +1,50 @@
+#pragma author ogmini https://github.com/ogmini
+#pragma description Windows 11 Notepad Window State file %localappdata%\Packages\Microsoft.WindowsNotepad_8wekyb3d8bbwe\LocalState\WindowState
+
+#include <std/string.pat>
+#include <type/leb128.pat>
+#include <std/time.pat>
+#include <std/core.pat>
+
+using ul = type::uLEB128;
+using int = u32;
+
+struct Tab
+{
+    u128 GUID;
+};
+
+struct WindowState
+{
+    char HeaderIdentifier[2]; // NP
+    ul SequenceNumber;
+    ul BytesToCRC32;
+    u8 Delim[1];
+    ul NumberTabs;
+
+    Tab Tabs[NumberTabs];
+    
+    ul ActiveTab;
+    
+    int CoordTopLeftX;
+    int CoordTopLeftY;
+    
+    int CoordBottomRightX;
+    int CoordBottomRightY;
+    
+    int WindowSizeWidth;
+    int WindowSizeHeight;
+    
+    u8 Delim2[1];
+    
+    int CRC32;
+
+    u8 SlackSpace[while(!std::mem::eof())];
+};
+
+
+
+
+// -- Declaration --
+
+WindowState state @ 0x0;

patterns/nro.hexpat

@@ -1,8 +1,8 @@
 #pragma author WerWolv
 #pragma description Nintendo Switch NRO files
 
-#include <std/io.pat>
-#include <std/sys.pat>
+import std.io;
+import std.sys;
 
 struct MOD0 {
 	char magic[4];

patterns/ntag.hexpat

@@ -1,7 +1,7 @@
 #pragma author WerWolv
 #pragma description NTAG213/NTAG215/NTAG216, NFC Forum Type 2 Tag compliant IC
 
-#include <std/core.pat>
+import std.core;
 
 using BitfieldOrder = std::core::BitfieldOrder;
 

patterns/ogg.hexpat

@@ -3,8 +3,8 @@
 
 #pragma MIME audio/ogg
 
-#include <std/core.pat>
-#include <std/mem.pat>
+import std.core;
+import std.mem;
 
 bitfield HeaderType {
 	Continuation	: 1;

patterns/pbz.hexpat

@@ -6,8 +6,8 @@
 //
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include <std/mem.pat>
-#include <type/magic.pat>
+import std.mem;
+import type.magic;
 
 #pragma endian big
 

patterns/pcap.hexpat

@@ -1,6 +1,6 @@
 #pragma description pcap header and packets
 
-#include <std/mem.pat>
+import std.mem;
 #pragma MIME application/vnd.tcpdump.pcap
 
 enum network_type : u32 {

patterns/pcx.hexpat

@@ -3,7 +3,7 @@
 
 #pragma MIME application/x-pcx
 
-#include <std/io.pat>
+import std.io;
 
 enum Encoding : u8 {
     NoEncoding = 0x00,

patterns/pe.hexpat

@@ -3,11 +3,12 @@
 
 #pragma MIME application/x-dosexec
 #pragma MIME application/x-msdownload
+#pragma MIME application/vnd.microsoft.portable-executable
 
-#include <std/core.pat>
-#include <std/string.pat>
-#include <type/guid.pat>
-#include <type/time.pat>
+import std.core;
+import std.string;
+import type.guid;
+import type.time;
 
 struct DOSHeader {
 	char signature[2] [[hex::spec_name("e_magic")]];
@@ -921,7 +922,7 @@ bitfield BaseRelocationWord {
 struct BaseRelocationBlock {
 	u32 pageRVA;
 	u32 blockSize;
-	BaseRelocationWord word;
+	BaseRelocationWord word[while($ < addressof(this) + this.blockSize)] [[inline]];
 };
 
 struct BaseRelocationTable {