polyfile-weave 0.5.5__py3-none-any.whl

polyfile/kaitai/parsers/heaps_pak.py

@@ -0,0 +1,177 @@
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+import kaitaistruct
+from kaitaistruct import KaitaiStruct, KaitaiStream, BytesIO
+import collections
+
+
+if parse_version(kaitaistruct.__version__) < parse_version('0.9'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.9 or later is required, but you have %s" % (kaitaistruct.__version__))
+
+class HeapsPak(KaitaiStruct):
+    """
+    .. seealso::
+       Source - https://github.com/HeapsIO/heaps/blob/2bbc2b386952dfd8856c04a854bb706a52cb4b58/hxd/fmt/pak/Reader.hx
+    """
+    SEQ_FIELDS = ["header"]
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        self._debug['header']['start'] = self._io.pos()
+        self.header = HeapsPak.Header(self._io, self, self._root)
+        self.header._read()
+        self._debug['header']['end'] = self._io.pos()
+
+    class Header(KaitaiStruct):
+        SEQ_FIELDS = ["magic1", "version", "len_header", "len_data", "root_entry", "magic2"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['magic1']['start'] = self._io.pos()
+            self.magic1 = self._io.read_bytes(3)
+            self._debug['magic1']['end'] = self._io.pos()
+            if not self.magic1 == b"\x50\x41\x4B":
+                raise kaitaistruct.ValidationNotEqualError(b"\x50\x41\x4B", self.magic1, self._io, u"/types/header/seq/0")
+            self._debug['version']['start'] = self._io.pos()
+            self.version = self._io.read_u1()
+            self._debug['version']['end'] = self._io.pos()
+            self._debug['len_header']['start'] = self._io.pos()
+            self.len_header = self._io.read_u4le()
+            self._debug['len_header']['end'] = self._io.pos()
+            self._debug['len_data']['start'] = self._io.pos()
+            self.len_data = self._io.read_u4le()
+            self._debug['len_data']['end'] = self._io.pos()
+            self._debug['root_entry']['start'] = self._io.pos()
+            self._raw_root_entry = self._io.read_bytes((self.len_header - 16))
+            _io__raw_root_entry = KaitaiStream(BytesIO(self._raw_root_entry))
+            self.root_entry = HeapsPak.Header.Entry(_io__raw_root_entry, self, self._root)
+            self.root_entry._read()
+            self._debug['root_entry']['end'] = self._io.pos()
+            self._debug['magic2']['start'] = self._io.pos()
+            self.magic2 = self._io.read_bytes(4)
+            self._debug['magic2']['end'] = self._io.pos()
+            if not self.magic2 == b"\x44\x41\x54\x41":
+                raise kaitaistruct.ValidationNotEqualError(b"\x44\x41\x54\x41", self.magic2, self._io, u"/types/header/seq/5")
+
+        class Entry(KaitaiStruct):
+            """
+            .. seealso::
+               Source - https://github.com/HeapsIO/heaps/blob/2bbc2b386952dfd8856c04a854bb706a52cb4b58/hxd/fmt/pak/Data.hx
+            """
+            SEQ_FIELDS = ["len_name", "name", "flags", "body"]
+            def __init__(self, _io, _parent=None, _root=None):
+                self._io = _io
+                self._parent = _parent
+                self._root = _root if _root else self
+                self._debug = collections.defaultdict(dict)
+
+            def _read(self):
+                self._debug['len_name']['start'] = self._io.pos()
+                self.len_name = self._io.read_u1()
+                self._debug['len_name']['end'] = self._io.pos()
+                self._debug['name']['start'] = self._io.pos()
+                self.name = (self._io.read_bytes(self.len_name)).decode(u"UTF-8")
+                self._debug['name']['end'] = self._io.pos()
+                self._debug['flags']['start'] = self._io.pos()
+                self.flags = HeapsPak.Header.Entry.Flags(self._io, self, self._root)
+                self.flags._read()
+                self._debug['flags']['end'] = self._io.pos()
+                self._debug['body']['start'] = self._io.pos()
+                _on = self.flags.is_dir
+                if _on == True:
+                    self.body = HeapsPak.Header.Dir(self._io, self, self._root)
+                    self.body._read()
+                elif _on == False:
+                    self.body = HeapsPak.Header.File(self._io, self, self._root)
+                    self.body._read()
+                self._debug['body']['end'] = self._io.pos()
+
+            class Flags(KaitaiStruct):
+                SEQ_FIELDS = ["unused", "is_dir"]
+                def __init__(self, _io, _parent=None, _root=None):
+                    self._io = _io
+                    self._parent = _parent
+                    self._root = _root if _root else self
+                    self._debug = collections.defaultdict(dict)
+
+                def _read(self):
+                    self._debug['unused']['start'] = self._io.pos()
+                    self.unused = self._io.read_bits_int_be(7)
+                    self._debug['unused']['end'] = self._io.pos()
+                    self._debug['is_dir']['start'] = self._io.pos()
+                    self.is_dir = self._io.read_bits_int_be(1) != 0
+                    self._debug['is_dir']['end'] = self._io.pos()
+
+
+
+        class File(KaitaiStruct):
+            SEQ_FIELDS = ["ofs_data", "len_data", "checksum"]
+            def __init__(self, _io, _parent=None, _root=None):
+                self._io = _io
+                self._parent = _parent
+                self._root = _root if _root else self
+                self._debug = collections.defaultdict(dict)
+
+            def _read(self):
+                self._debug['ofs_data']['start'] = self._io.pos()
+                self.ofs_data = self._io.read_u4le()
+                self._debug['ofs_data']['end'] = self._io.pos()
+                self._debug['len_data']['start'] = self._io.pos()
+                self.len_data = self._io.read_u4le()
+                self._debug['len_data']['end'] = self._io.pos()
+                self._debug['checksum']['start'] = self._io.pos()
+                self.checksum = self._io.read_bytes(4)
+                self._debug['checksum']['end'] = self._io.pos()
+
+            @property
+            def data(self):
+                if hasattr(self, '_m_data'):
+                    return self._m_data if hasattr(self, '_m_data') else None
+
+                io = self._root._io
+                _pos = io.pos()
+                io.seek((self._root.header.len_header + self.ofs_data))
+                self._debug['_m_data']['start'] = io.pos()
+                self._m_data = io.read_bytes(self.len_data)
+                self._debug['_m_data']['end'] = io.pos()
+                io.seek(_pos)
+                return self._m_data if hasattr(self, '_m_data') else None
+
+
+        class Dir(KaitaiStruct):
+            SEQ_FIELDS = ["num_entries", "entries"]
+            def __init__(self, _io, _parent=None, _root=None):
+                self._io = _io
+                self._parent = _parent
+                self._root = _root if _root else self
+                self._debug = collections.defaultdict(dict)
+
+            def _read(self):
+                self._debug['num_entries']['start'] = self._io.pos()
+                self.num_entries = self._io.read_u4le()
+                self._debug['num_entries']['end'] = self._io.pos()
+                self._debug['entries']['start'] = self._io.pos()
+                self.entries = [None] * (self.num_entries)
+                for i in range(self.num_entries):
+                    if not 'arr' in self._debug['entries']:
+                        self._debug['entries']['arr'] = []
+                    self._debug['entries']['arr'].append({'start': self._io.pos()})
+                    _t_entries = HeapsPak.Header.Entry(self._io, self, self._root)
+                    _t_entries._read()
+                    self.entries[i] = _t_entries
+                    self._debug['entries']['arr'][i]['end'] = self._io.pos()
+
+                self._debug['entries']['end'] = self._io.pos()
+
+
+
+

polyfile/kaitai/parsers/heroes_of_might_and_magic_agg.py

@@ -0,0 +1,116 @@
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+import kaitaistruct
+from kaitaistruct import KaitaiStruct, KaitaiStream, BytesIO
+import collections
+
+
+if parse_version(kaitaistruct.__version__) < parse_version('0.9'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.9 or later is required, but you have %s" % (kaitaistruct.__version__))
+
+class HeroesOfMightAndMagicAgg(KaitaiStruct):
+    """
+    .. seealso::
+       Source - https://web.archive.org/web/20170215190034/http://rewiki.regengedanken.de/wiki/.AGG_(Heroes_of_Might_and_Magic)
+    """
+    SEQ_FIELDS = ["num_files", "entries"]
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        self._debug['num_files']['start'] = self._io.pos()
+        self.num_files = self._io.read_u2le()
+        self._debug['num_files']['end'] = self._io.pos()
+        self._debug['entries']['start'] = self._io.pos()
+        self.entries = [None] * (self.num_files)
+        for i in range(self.num_files):
+            if not 'arr' in self._debug['entries']:
+                self._debug['entries']['arr'] = []
+            self._debug['entries']['arr'].append({'start': self._io.pos()})
+            _t_entries = HeroesOfMightAndMagicAgg.Entry(self._io, self, self._root)
+            _t_entries._read()
+            self.entries[i] = _t_entries
+            self._debug['entries']['arr'][i]['end'] = self._io.pos()
+
+        self._debug['entries']['end'] = self._io.pos()
+
+    class Entry(KaitaiStruct):
+        SEQ_FIELDS = ["hash", "offset", "size", "size2"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['hash']['start'] = self._io.pos()
+            self.hash = self._io.read_u2le()
+            self._debug['hash']['end'] = self._io.pos()
+            self._debug['offset']['start'] = self._io.pos()
+            self.offset = self._io.read_u4le()
+            self._debug['offset']['end'] = self._io.pos()
+            self._debug['size']['start'] = self._io.pos()
+            self.size = self._io.read_u4le()
+            self._debug['size']['end'] = self._io.pos()
+            self._debug['size2']['start'] = self._io.pos()
+            self.size2 = self._io.read_u4le()
+            self._debug['size2']['end'] = self._io.pos()
+
+        @property
+        def body(self):
+            if hasattr(self, '_m_body'):
+                return self._m_body if hasattr(self, '_m_body') else None
+
+            _pos = self._io.pos()
+            self._io.seek(self.offset)
+            self._debug['_m_body']['start'] = self._io.pos()
+            self._m_body = self._io.read_bytes(self.size)
+            self._debug['_m_body']['end'] = self._io.pos()
+            self._io.seek(_pos)
+            return self._m_body if hasattr(self, '_m_body') else None
+
+
+    class Filename(KaitaiStruct):
+        SEQ_FIELDS = ["str"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['str']['start'] = self._io.pos()
+            self.str = (self._io.read_bytes_term(0, False, True, True)).decode(u"ASCII")
+            self._debug['str']['end'] = self._io.pos()
+
+
+    @property
+    def filenames(self):
+        if hasattr(self, '_m_filenames'):
+            return self._m_filenames if hasattr(self, '_m_filenames') else None
+
+        _pos = self._io.pos()
+        self._io.seek((self.entries[-1].offset + self.entries[-1].size))
+        self._debug['_m_filenames']['start'] = self._io.pos()
+        self._raw__m_filenames = [None] * (self.num_files)
+        self._m_filenames = [None] * (self.num_files)
+        for i in range(self.num_files):
+            if not 'arr' in self._debug['_m_filenames']:
+                self._debug['_m_filenames']['arr'] = []
+            self._debug['_m_filenames']['arr'].append({'start': self._io.pos()})
+            self._raw__m_filenames[i] = self._io.read_bytes(15)
+            _io__raw__m_filenames = KaitaiStream(BytesIO(self._raw__m_filenames[i]))
+            _t__m_filenames = HeroesOfMightAndMagicAgg.Filename(_io__raw__m_filenames, self, self._root)
+            _t__m_filenames._read()
+            self._m_filenames[i] = _t__m_filenames
+            self._debug['_m_filenames']['arr'][i]['end'] = self._io.pos()
+
+        self._debug['_m_filenames']['end'] = self._io.pos()
+        self._io.seek(_pos)
+        return self._m_filenames if hasattr(self, '_m_filenames') else None
+
+

polyfile/kaitai/parsers/heroes_of_might_and_magic_bmp.py

@@ -0,0 +1,34 @@
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+import kaitaistruct
+from kaitaistruct import KaitaiStruct, KaitaiStream, BytesIO
+import collections
+
+
+if parse_version(kaitaistruct.__version__) < parse_version('0.9'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.9 or later is required, but you have %s" % (kaitaistruct.__version__))
+
+class HeroesOfMightAndMagicBmp(KaitaiStruct):
+    SEQ_FIELDS = ["magic", "width", "height", "data"]
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        self._debug['magic']['start'] = self._io.pos()
+        self.magic = self._io.read_u2le()
+        self._debug['magic']['end'] = self._io.pos()
+        self._debug['width']['start'] = self._io.pos()
+        self.width = self._io.read_u2le()
+        self._debug['width']['end'] = self._io.pos()
+        self._debug['height']['start'] = self._io.pos()
+        self.height = self._io.read_u2le()
+        self._debug['height']['end'] = self._io.pos()
+        self._debug['data']['start'] = self._io.pos()
+        self.data = self._io.read_bytes((self.width * self.height))
+        self._debug['data']['end'] = self._io.pos()
+
+

polyfile/kaitai/parsers/icmp_packet.py

@@ -0,0 +1,136 @@
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+import kaitaistruct
+from kaitaistruct import KaitaiStruct, KaitaiStream, BytesIO
+from enum import Enum
+import collections
+
+
+if parse_version(kaitaistruct.__version__) < parse_version('0.9'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.9 or later is required, but you have %s" % (kaitaistruct.__version__))
+
+class IcmpPacket(KaitaiStruct):
+
+    class IcmpTypeEnum(Enum):
+        echo_reply = 0
+        destination_unreachable = 3
+        source_quench = 4
+        redirect = 5
+        echo = 8
+        time_exceeded = 11
+    SEQ_FIELDS = ["icmp_type", "destination_unreachable", "time_exceeded", "echo"]
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        self._debug['icmp_type']['start'] = self._io.pos()
+        self.icmp_type = KaitaiStream.resolve_enum(IcmpPacket.IcmpTypeEnum, self._io.read_u1())
+        self._debug['icmp_type']['end'] = self._io.pos()
+        if self.icmp_type == IcmpPacket.IcmpTypeEnum.destination_unreachable:
+            self._debug['destination_unreachable']['start'] = self._io.pos()
+            self.destination_unreachable = IcmpPacket.DestinationUnreachableMsg(self._io, self, self._root)
+            self.destination_unreachable._read()
+            self._debug['destination_unreachable']['end'] = self._io.pos()
+
+        if self.icmp_type == IcmpPacket.IcmpTypeEnum.time_exceeded:
+            self._debug['time_exceeded']['start'] = self._io.pos()
+            self.time_exceeded = IcmpPacket.TimeExceededMsg(self._io, self, self._root)
+            self.time_exceeded._read()
+            self._debug['time_exceeded']['end'] = self._io.pos()
+
+        if  ((self.icmp_type == IcmpPacket.IcmpTypeEnum.echo) or (self.icmp_type == IcmpPacket.IcmpTypeEnum.echo_reply)) :
+            self._debug['echo']['start'] = self._io.pos()
+            self.echo = IcmpPacket.EchoMsg(self._io, self, self._root)
+            self.echo._read()
+            self._debug['echo']['end'] = self._io.pos()
+
+
+    class DestinationUnreachableMsg(KaitaiStruct):
+
+        class DestinationUnreachableCode(Enum):
+            net_unreachable = 0
+            host_unreachable = 1
+            protocol_unreachable = 2
+            port_unreachable = 3
+            fragmentation_needed_and_df_set = 4
+            source_route_failed = 5
+            dst_net_unkown = 6
+            sdt_host_unkown = 7
+            src_isolated = 8
+            net_prohibited_by_admin = 9
+            host_prohibited_by_admin = 10
+            net_unreachable_for_tos = 11
+            host_unreachable_for_tos = 12
+            communication_prohibited_by_admin = 13
+            host_precedence_violation = 14
+            precedence_cuttoff_in_effect = 15
+        SEQ_FIELDS = ["code", "checksum"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['code']['start'] = self._io.pos()
+            self.code = KaitaiStream.resolve_enum(IcmpPacket.DestinationUnreachableMsg.DestinationUnreachableCode, self._io.read_u1())
+            self._debug['code']['end'] = self._io.pos()
+            self._debug['checksum']['start'] = self._io.pos()
+            self.checksum = self._io.read_u2be()
+            self._debug['checksum']['end'] = self._io.pos()
+
+
+    class TimeExceededMsg(KaitaiStruct):
+
+        class TimeExceededCode(Enum):
+            time_to_live_exceeded_in_transit = 0
+            fragment_reassembly_time_exceeded = 1
+        SEQ_FIELDS = ["code", "checksum"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['code']['start'] = self._io.pos()
+            self.code = KaitaiStream.resolve_enum(IcmpPacket.TimeExceededMsg.TimeExceededCode, self._io.read_u1())
+            self._debug['code']['end'] = self._io.pos()
+            self._debug['checksum']['start'] = self._io.pos()
+            self.checksum = self._io.read_u2be()
+            self._debug['checksum']['end'] = self._io.pos()
+
+
+    class EchoMsg(KaitaiStruct):
+        SEQ_FIELDS = ["code", "checksum", "identifier", "seq_num", "data"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['code']['start'] = self._io.pos()
+            self.code = self._io.read_bytes(1)
+            self._debug['code']['end'] = self._io.pos()
+            if not self.code == b"\x00":
+                raise kaitaistruct.ValidationNotEqualError(b"\x00", self.code, self._io, u"/types/echo_msg/seq/0")
+            self._debug['checksum']['start'] = self._io.pos()
+            self.checksum = self._io.read_u2be()
+            self._debug['checksum']['end'] = self._io.pos()
+            self._debug['identifier']['start'] = self._io.pos()
+            self.identifier = self._io.read_u2be()
+            self._debug['identifier']['end'] = self._io.pos()
+            self._debug['seq_num']['start'] = self._io.pos()
+            self.seq_num = self._io.read_u2be()
+            self._debug['seq_num']['end'] = self._io.pos()
+            self._debug['data']['start'] = self._io.pos()
+            self.data = self._io.read_bytes_full()
+            self._debug['data']['end'] = self._io.pos()
+
+
+

polyfile/kaitai/parsers/ico.py

@@ -0,0 +1,129 @@
+# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+from pkg_resources import parse_version
+import kaitaistruct
+from kaitaistruct import KaitaiStruct, KaitaiStream, BytesIO
+import collections
+
+
+if parse_version(kaitaistruct.__version__) < parse_version('0.9'):
+    raise Exception("Incompatible Kaitai Struct Python API: 0.9 or later is required, but you have %s" % (kaitaistruct.__version__))
+
+class Ico(KaitaiStruct):
+    """Microsoft Windows uses specific file format to store applications
+    icons - ICO. This is a container that contains one or more image
+    files (effectively, DIB parts of BMP files or full PNG files are
+    contained inside).
+    
+    .. seealso::
+       Source - https://learn.microsoft.com/en-us/previous-versions/ms997538(v=msdn.10)
+    """
+    SEQ_FIELDS = ["magic", "num_images", "images"]
+    def __init__(self, _io, _parent=None, _root=None):
+        self._io = _io
+        self._parent = _parent
+        self._root = _root if _root else self
+        self._debug = collections.defaultdict(dict)
+
+    def _read(self):
+        self._debug['magic']['start'] = self._io.pos()
+        self.magic = self._io.read_bytes(4)
+        self._debug['magic']['end'] = self._io.pos()
+        if not self.magic == b"\x00\x00\x01\x00":
+            raise kaitaistruct.ValidationNotEqualError(b"\x00\x00\x01\x00", self.magic, self._io, u"/seq/0")
+        self._debug['num_images']['start'] = self._io.pos()
+        self.num_images = self._io.read_u2le()
+        self._debug['num_images']['end'] = self._io.pos()
+        self._debug['images']['start'] = self._io.pos()
+        self.images = [None] * (self.num_images)
+        for i in range(self.num_images):
+            if not 'arr' in self._debug['images']:
+                self._debug['images']['arr'] = []
+            self._debug['images']['arr'].append({'start': self._io.pos()})
+            _t_images = Ico.IconDirEntry(self._io, self, self._root)
+            _t_images._read()
+            self.images[i] = _t_images
+            self._debug['images']['arr'][i]['end'] = self._io.pos()
+
+        self._debug['images']['end'] = self._io.pos()
+
+    class IconDirEntry(KaitaiStruct):
+        SEQ_FIELDS = ["width", "height", "num_colors", "reserved", "num_planes", "bpp", "len_img", "ofs_img"]
+        def __init__(self, _io, _parent=None, _root=None):
+            self._io = _io
+            self._parent = _parent
+            self._root = _root if _root else self
+            self._debug = collections.defaultdict(dict)
+
+        def _read(self):
+            self._debug['width']['start'] = self._io.pos()
+            self.width = self._io.read_u1()
+            self._debug['width']['end'] = self._io.pos()
+            self._debug['height']['start'] = self._io.pos()
+            self.height = self._io.read_u1()
+            self._debug['height']['end'] = self._io.pos()
+            self._debug['num_colors']['start'] = self._io.pos()
+            self.num_colors = self._io.read_u1()
+            self._debug['num_colors']['end'] = self._io.pos()
+            self._debug['reserved']['start'] = self._io.pos()
+            self.reserved = self._io.read_bytes(1)
+            self._debug['reserved']['end'] = self._io.pos()
+            if not self.reserved == b"\x00":
+                raise kaitaistruct.ValidationNotEqualError(b"\x00", self.reserved, self._io, u"/types/icon_dir_entry/seq/3")
+            self._debug['num_planes']['start'] = self._io.pos()
+            self.num_planes = self._io.read_u2le()
+            self._debug['num_planes']['end'] = self._io.pos()
+            self._debug['bpp']['start'] = self._io.pos()
+            self.bpp = self._io.read_u2le()
+            self._debug['bpp']['end'] = self._io.pos()
+            self._debug['len_img']['start'] = self._io.pos()
+            self.len_img = self._io.read_u4le()
+            self._debug['len_img']['end'] = self._io.pos()
+            self._debug['ofs_img']['start'] = self._io.pos()
+            self.ofs_img = self._io.read_u4le()
+            self._debug['ofs_img']['end'] = self._io.pos()
+
+        @property
+        def img(self):
+            """Raw image data. Use `is_png` to determine whether this is an
+            embedded PNG file (true) or a DIB bitmap (false) and call a
+            relevant parser, if needed to parse image data further.
+            """
+            if hasattr(self, '_m_img'):
+                return self._m_img if hasattr(self, '_m_img') else None
+
+            _pos = self._io.pos()
+            self._io.seek(self.ofs_img)
+            self._debug['_m_img']['start'] = self._io.pos()
+            self._m_img = self._io.read_bytes(self.len_img)
+            self._debug['_m_img']['end'] = self._io.pos()
+            self._io.seek(_pos)
+            return self._m_img if hasattr(self, '_m_img') else None
+
+        @property
+        def png_header(self):
+            """Pre-reads first 8 bytes of the image to determine if it's an
+            embedded PNG file.
+            """
+            if hasattr(self, '_m_png_header'):
+                return self._m_png_header if hasattr(self, '_m_png_header') else None
+
+            _pos = self._io.pos()
+            self._io.seek(self.ofs_img)
+            self._debug['_m_png_header']['start'] = self._io.pos()
+            self._m_png_header = self._io.read_bytes(8)
+            self._debug['_m_png_header']['end'] = self._io.pos()
+            self._io.seek(_pos)
+            return self._m_png_header if hasattr(self, '_m_png_header') else None
+
+        @property
+        def is_png(self):
+            """True if this image is in PNG format."""
+            if hasattr(self, '_m_is_png'):
+                return self._m_is_png if hasattr(self, '_m_is_png') else None
+
+            self._m_is_png = self.png_header == b"\x89\x50\x4E\x47\x0D\x0A\x1A\x0A"
+            return self._m_is_png if hasattr(self, '_m_is_png') else None
+
+
+