dfindexeddb 20241105__py3-none-any.whl → 20251109__py3-none-any.whl

dfindexeddb/indexeddb/chromium/record.py

@@ -15,28 +15,31 @@
 """Parses Chromium IndexedDb structures."""
 from __future__ import annotations
 
-from dataclasses import dataclass, field
-from datetime import datetime
 import io
 import pathlib
 import sys
 import traceback
-from typing import Any, BinaryIO, Generator, Optional, Tuple, Type, TypeVar, \
-    Union
-
-import snappy
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import (
+    Any,
+    BinaryIO,
+    Generator,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+)
 
 from dfindexeddb import errors
-from dfindexeddb.indexeddb.chromium import blink
-from dfindexeddb.indexeddb.chromium import definitions
-from dfindexeddb.leveldb import record
-from dfindexeddb.leveldb import utils
-
+from dfindexeddb.indexeddb.chromium import blink, definitions
+from dfindexeddb.leveldb import record, utils
 
-T = TypeVar('T')
+T = TypeVar("T")
 
 
-@dataclass
+@dataclass(frozen=True)
 class KeyPrefix(utils.FromDecoderMixin):
   """The IndexedDB key prefix.
 
@@ -46,6 +49,7 @@ class KeyPrefix(utils.FromDecoderMixin):
     object_store_id: the object store ID.
     index_id: the index ID.
   """
+
   offset: int = field(compare=False)
   database_id: int
   object_store_id: int
@@ -53,9 +57,7 @@ class KeyPrefix(utils.FromDecoderMixin):
 
   @classmethod
   def FromDecoder(
-      cls,
-      decoder: utils.LevelDBDecoder,
-      base_offset: int = 0
+      cls, decoder: utils.LevelDBDecoder, base_offset: int = 0
   ) -> KeyPrefix:
     """Decodes a KeyPrefix from the current position of a LevelDBDecoder.
 
@@ -77,23 +79,24 @@ class KeyPrefix(utils.FromDecoderMixin):
     index_id_length = (raw_prefix[0] & 0x03) + 1
 
     if database_id_length < 1 or database_id_length > 8:
-      raise errors.ParserError('Invalid database ID length')
+      raise errors.ParserError("Invalid database ID length")
 
     if object_store_id_length < 1 or object_store_id_length > 8:
-      raise errors.ParserError('Invalid object store ID length')
+      raise errors.ParserError("Invalid object store ID length")
 
     if index_id_length < 1 or index_id_length > 4:
-      raise errors.ParserError('Invalid index ID length')
+      raise errors.ParserError("Invalid index ID length")
 
-    _, database_id = decoder.DecodeInt(database_id_length)
-    _, object_store_id = decoder.DecodeInt(object_store_id_length)
-    _, index_id = decoder.DecodeInt(index_id_length)
+    _, database_id = decoder.DecodeInt(database_id_length, signed=False)
+    _, object_store_id = decoder.DecodeInt(object_store_id_length, signed=False)
+    _, index_id = decoder.DecodeInt(index_id_length, signed=False)
 
     return cls(
         offset=base_offset + offset,
         database_id=database_id,
         object_store_id=object_store_id,
-        index_id=index_id)
+        index_id=index_id,
+    )
 
   def GetKeyPrefixType(self) -> definitions.KeyPrefixType:
     """Returns the KeyPrefixType.
@@ -116,7 +119,8 @@ class KeyPrefix(utils.FromDecoderMixin):
     if self.index_id >= 30:
       return definitions.KeyPrefixType.INDEX_DATA
     raise errors.ParserError(
-        f'Unknown KeyPrefixType (index_id={self.index_id})')
+        f"Unknown KeyPrefixType (index_id={self.index_id})"
+    )
 
 
 @dataclass
@@ -128,9 +132,10 @@ class IDBKey(utils.FromDecoderMixin):
     type: the type of the IDBKey.
     value: the value of the IDBKey.
   """
+
   offset: int = field(compare=False)
   type: definitions.IDBKeyType
-  value: Union[list, bytes, str, float, datetime, None]
+  value: Union[list[Any], bytes, str, float, datetime, None]
 
   _MAXIMUM_DEPTH = 2000
 
@@ -138,7 +143,7 @@ class IDBKey(utils.FromDecoderMixin):
   def FromDecoder(
       cls,
       decoder: utils.LevelDBDecoder,
-      base_offset: int = 0  #pylint: disable=unused-argument
+      base_offset: int = 0,  # pylint: disable=unused-argument
   ) -> IDBKey:
     """Decodes an IDBKey from the current position of a LevelDBDecoder.
 
@@ -155,10 +160,13 @@ class IDBKey(utils.FromDecoderMixin):
       RecursionError: if maximum depth encountered during parsing.
     """
 
-    def RecursiveParse(depth: int) -> Tuple[
-        int, definitions.IDBKeyType, Union[
-            list, bytes, str, float, datetime, None
-        ]]:
+    def RecursiveParse(
+        depth: int,
+    ) -> Tuple[
+        int,
+        definitions.IDBKeyType,
+        Union[list[Any], bytes, str, float, datetime, None],
+    ]:
       """Recursively parses IDBKeys.
 
       Args:
@@ -174,16 +182,17 @@ class IDBKey(utils.FromDecoderMixin):
         RecursionError: if maximum depth encountered during parsing.
       """
       if depth == cls._MAXIMUM_DEPTH:
-        raise RecursionError('Maximum recursion depth encountered during parse')
+        raise RecursionError("Maximum recursion depth encountered during parse")
       offset, key_type_value = decoder.DecodeInt(1)
       key_type = definitions.IDBKeyType(key_type_value)
+      value: Any = None
 
       if key_type == definitions.IDBKeyType.NULL:
         value = None
       elif key_type == definitions.IDBKeyType.ARRAY:
         _, length = decoder.DecodeVarint()
         if length < 0:
-          raise errors.ParserError('Invalid length encountered')
+          raise errors.ParserError("Invalid length encountered")
         value = []
         while length:
           entry = RecursiveParse(depth + 1)
@@ -195,13 +204,13 @@ class IDBKey(utils.FromDecoderMixin):
         _, value = decoder.DecodeStringWithLength()
       elif key_type == definitions.IDBKeyType.DATE:
         _, raw_value = decoder.DecodeDouble()
-        value = datetime.utcfromtimestamp(raw_value/1000.0)
+        value = datetime.utcfromtimestamp(raw_value / 1000.0)
       elif key_type == definitions.IDBKeyType.NUMBER:
         _, value = decoder.DecodeDouble()
       elif key_type == definitions.IDBKeyType.MIN_KEY:
         value = None
       else:
-        raise errors.ParserError('Invalid IndexedDbKeyType')
+        raise errors.ParserError("Invalid IndexedDbKeyType")
       return offset, key_type, value
 
     offset, key_type, value = RecursiveParse(0)
@@ -217,15 +226,14 @@ class IDBKeyPath(utils.FromDecoderMixin):
     type: the IDBKeyPath type.
     value: the IDBKeyPath value.
   """
+
   offset: int = field(compare=False)
   type: definitions.IDBKeyPathType
   value: Union[str, list[str], None]
 
   @classmethod
   def FromDecoder(
-      cls,
-      decoder: utils.LevelDBDecoder,
-      base_offset: int = 0
+      cls, decoder: utils.LevelDBDecoder, base_offset: int = 0
   ) -> IDBKeyPath:
     """Decodes an IDBKeyPath from the current position of a LevelDBDecoder.
 
@@ -240,11 +248,13 @@ class IDBKeyPath(utils.FromDecoderMixin):
       ParserError: on insufficient bytes or invalid array length during
         parsing or unsupported key path type.
     """
-    buffer = decoder.stream.getvalue()  #pytype: disable=attribute-error
+    buffer = decoder.stream.getvalue()  # type: ignore[attr-defined]
     if len(buffer) < 3:
-      raise errors.ParserError('Insufficient bytes to parse.')
+      raise errors.ParserError("Insufficient bytes to parse.")
 
-    if buffer[0:2] != b'\x00\x00':
+    value: str | list[str] | None = None
+
+    if buffer[0:2] != b"\x00\x00":
       offset, value = decoder.DecodeString()
       return IDBKeyPath(offset, definitions.IDBKeyPathType.STRING, value)
 
@@ -261,12 +271,12 @@ class IDBKeyPath(utils.FromDecoderMixin):
       value = []
       offset, count = decoder.DecodeVarint()
       if count < 0:
-        raise errors.ParserError(f'Invalid array length {count}')
+        raise errors.ParserError(f"Invalid array length {count}")
       for _ in range(count):
         _, entry = decoder.DecodeStringWithLength()
         value.append(entry)
     else:
-      raise errors.ParserError(f'Unsupported key_path_type {key_path_type}.')
+      raise errors.ParserError(f"Unsupported key_path_type {key_path_type}.")
     return IDBKeyPath(base_offset + offset, key_path_type, value)
 
 
@@ -279,15 +289,14 @@ class BlobJournalEntry(utils.FromDecoderMixin):
     database_id (int): the database ID.
     blob_number (int): the blob number.
   """
+
   offset: int = field(compare=False)
   database_id: int
   blob_number: int
 
   @classmethod
   def FromDecoder(
-      cls,
-      decoder: utils.LevelDBDecoder,
-      base_offset: int = 0
+      cls, decoder: utils.LevelDBDecoder, base_offset: int = 0
   ) -> BlobJournalEntry:
     """Decodes a BlobJournalEntry from the current position of a LevelDBDecoder.
 
@@ -300,8 +309,11 @@ class BlobJournalEntry(utils.FromDecoderMixin):
     """
     offset, database_id = decoder.DecodeUint64Varint()
     _, blob_number = decoder.DecodeUint64Varint()
-    return cls(offset=base_offset + offset, database_id=database_id,
-               blob_number=blob_number)
+    return cls(
+        offset=base_offset + offset,
+        database_id=database_id,
+        blob_number=blob_number,
+    )
 
 
 @dataclass
@@ -312,14 +324,13 @@ class BlobJournal(utils.FromDecoderMixin):
     offset (int): the offset.
     entries (list[BlobJournalEntry]): the list of blob journal entries.
   """
+
   offset: int = field(compare=False)
   entries: list[BlobJournalEntry]
 
   @classmethod
   def FromDecoder(
-      cls,
-      decoder: utils.LevelDBDecoder,
-      base_offset: int = 0
+      cls, decoder: utils.LevelDBDecoder, base_offset: int = 0
   ) -> BlobJournal:
     """Decodes a BlobJournal from the current position of a LevelDBDecoder.
 
@@ -360,6 +371,7 @@ class BaseIndexedDBKey:
     offset: the offset of the key (after the key_prefix).
     key_prefix: the key prefix.
   """
+
   offset: int
   key_prefix: KeyPrefix
 
@@ -374,7 +386,7 @@ class BaseIndexedDBKey:
     Raises:
       NotImplementedError.
     """
-    raise NotImplementedError(f'{self.__class__.__name__}.decode_value')
+    raise NotImplementedError(f"{self.__class__.__name__}.decode_value")
 
   def ParseValue(self, value_data: bytes) -> Any:
     """Parses the value from raw bytes.
@@ -392,11 +404,11 @@ class BaseIndexedDBKey:
 
   @classmethod
   def FromDecoder(
-      cls: T,
+      cls: Type[T],
       decoder: utils.LevelDBDecoder,
       key_prefix: KeyPrefix,
-      base_offset: int = 0
-  ) -> T:  #pylint: disable=unused-variable
+      base_offset: int = 0,
+  ) -> T:  # pylint: disable=unused-variable
     """Decodes the remaining key data from the current decoder position.
 
     Args:
@@ -410,7 +422,7 @@ class BaseIndexedDBKey:
     Raises:
       NotImplementedError.
     """
-    raise NotImplementedError(f'{cls.__class__.__name__}.decode_key')
+    raise NotImplementedError(f"{cls.__class__.__name__}.decode_key")
 
   @classmethod
   def FromStream(cls: Type[T], stream: BinaryIO, base_offset: int = 0) -> T:
@@ -425,8 +437,9 @@ class BaseIndexedDBKey:
     """
     decoder = utils.LevelDBDecoder(stream)
     key_prefix = KeyPrefix.FromDecoder(decoder, base_offset=base_offset)
-    return cls.FromDecoder(
-        decoder=decoder, key_prefix=key_prefix, base_offset=base_offset)
+    return cls.FromDecoder(  # type: ignore[no-any-return,attr-defined]
+        decoder=decoder, key_prefix=key_prefix, base_offset=base_offset
+    )
 
   @classmethod
   def FromBytes(cls: Type[T], raw_data: bytes, base_offset: int = 0) -> T:
@@ -440,7 +453,9 @@ class BaseIndexedDBKey:
       The decoded key.
     """
     stream = io.BytesIO(raw_data)
-    return cls.FromStream(stream=stream, base_offset=base_offset)
+    return cls.FromStream(  # type: ignore[no-any-return,attr-defined]
+        stream=stream, base_offset=base_offset
+    )
 
 
 @dataclass
@@ -456,12 +471,12 @@ class SchemaVersionKey(BaseIndexedDBKey):
       cls,
       decoder: utils.LevelDBDecoder,
       key_prefix: KeyPrefix,
-      base_offset: int = 0
+      base_offset: int = 0,
   ) -> SchemaVersionKey:
     """Decodes the schema version key."""
     offset, key_type = decoder.DecodeUint8()
     if key_type != definitions.GlobalMetadataKeyType.SCHEMA_VERSION:
-      raise errors.ParserError('Not a SchemaVersionKey')
+      raise errors.ParserError("Not a SchemaVersionKey")
     return cls(offset=base_offset + offset, key_prefix=key_prefix)
 
 
@@ -478,12 +493,12 @@ class MaxDatabaseIdKey(BaseIndexedDBKey):
       cls,
       decoder: utils.LevelDBDecoder,
       key_prefix: KeyPrefix,
-      base_offset: int = 0
+      base_offset: int = 0,
   ) -> MaxDatabaseIdKey:
     """Decodes the maximum database key."""
     offset, key_type = decoder.DecodeUint8()
     if key_type != definitions.GlobalMetadataKeyType.MAX_DATABASE_ID:
-      raise errors.ParserError('Not a MaxDatabaseIdKey')
+      raise errors.ParserError("Not a MaxDatabaseIdKey")
     return cls(offset=base_offset + offset, key_prefix=key_prefix)
 
 
@@ -500,12 +515,12 @@ class DataVersionKey(BaseIndexedDBKey):
       cls,
       decoder: utils.LevelDBDecoder,
       key_prefix: KeyPrefix,
-      base_offset: int = 0
+      base_offset: int = 0,
   ) -> DataVersionKey:
     """Decodes the data version key."""
     offset, key_type = decoder.DecodeUint8()
     if key_type != definitions.GlobalMetadataKeyType.DATA_VERSION:
-      raise errors.ParserError('Not a DataVersionKey')
+      raise errors.ParserError("Not a DataVersionKey")
     return cls(offset=base_offset + offset, key_prefix=key_prefix)
 
 
@@ -522,12 +537,12 @@ class RecoveryBlobJournalKey(BaseIndexedDBKey):
       cls,
       decoder: utils.LevelDBDecoder,
       key_prefix: KeyPrefix,
-      base_offset: int = 0
+      base_offset: int = 0,
   ) -> RecoveryBlobJournalKey:
     """Decodes the recovery blob journal key."""
     offset, key_type = decoder.DecodeUint8()
     if key_type != definitions.GlobalMetadataKeyType.RECOVERY_BLOB_JOURNAL:
-      raise errors.ParserError('Not a RecoveryBlobJournalKey')
+      raise errors.ParserError("Not a RecoveryBlobJournalKey")
     return cls(offset=base_offset + offset, key_prefix=key_prefix)
 
 
@@ -544,12 +559,12 @@ class ActiveBlobJournalKey(BaseIndexedDBKey):
       cls,
       decoder: utils.LevelDBDecoder,
       key_prefix: KeyPrefix,
-      base_offset: int = 0
+      base_offset: int = 0,
   ) -> ActiveBlobJournalKey:
     """Decodes the active blob journal value."""
     offset, key_type = decoder.DecodeUint8()
     if key_type != definitions.GlobalMetadataKeyType.ACTIVE_BLOB_JOURNAL:
-      raise errors.ParserError('Not a ActiveBlobJournalKey')
+      raise errors.ParserError("Not a ActiveBlobJournalKey")
     return cls(offset=base_offset + offset, key_prefix=key_prefix)
 
 
@@ -560,19 +575,19 @@ class EarliestSweepKey(BaseIndexedDBKey):
   def DecodeValue(self, decoder: utils.LevelDBDecoder) -> int:
     """Decodes the earliest sweep value."""
     _, data = decoder.ReadBytes()
-    return int.from_bytes(data, byteorder='little', signed=False)
+    return int.from_bytes(data, byteorder="little", signed=False)
 
   @classmethod
   def FromDecoder(
       cls,
       decoder: utils.LevelDBDecoder,
       key_prefix: KeyPrefix,
-      base_offset: int = 0
+      base_offset: int = 0,
   ) -> EarliestSweepKey:
     """Decodes the earliest sweep value."""
     offset, key_type = decoder.DecodeUint8()
     if key_type != definitions.GlobalMetadataKeyType.EARLIEST_SWEEP:
-      raise errors.ParserError('Not a EarliestSweepKey')
+      raise errors.ParserError("Not a EarliestSweepKey")
     return cls(offset=base_offset + offset, key_prefix=key_prefix)
 
 
@@ -583,19 +598,19 @@ class EarliestCompactionTimeKey(BaseIndexedDBKey):
   def DecodeValue(self, decoder: utils.LevelDBDecoder) -> int:
     """Decodes the earliest compaction time value."""
     _, data = decoder.ReadBytes()
-    return int.from_bytes(data, byteorder='little', signed=False)
+    return int.from_bytes(data, byteorder="little", signed=False)
 
   @classmethod
   def FromDecoder(
       cls,
       decoder: utils.LevelDBDecoder,
       key_prefix: KeyPrefix,
-      base_offset: int = 0
+      base_offset: int = 0,
   ) -> EarliestCompactionTimeKey:
     """Decodes the earliest compaction time key."""
     offset, key_type = decoder.DecodeUint8()
     if key_type != definitions.GlobalMetadataKeyType.EARLIEST_COMPACTION_TIME:
-      raise errors.ParserError('Not a EarliestCompactionTimeKey')
+      raise errors.ParserError("Not a EarliestCompactionTimeKey")
     return cls(offset=base_offset + offset, key_prefix=key_prefix)
 
 
@@ -605,7 +620,7 @@ class ScopesPrefixKey(BaseIndexedDBKey):
 
   def DecodeValue(self, decoder: utils.LevelDBDecoder) -> Optional[bytes]:
     """Decodes the scopes prefix value."""
-    if decoder.NumRemainingBytes:
+    if decoder.NumRemainingBytes():
       return decoder.ReadBytes()[1]
     return None
 
@@ -614,12 +629,12 @@ class ScopesPrefixKey(BaseIndexedDBKey):
       cls,
       decoder: utils.LevelDBDecoder,
       key_prefix: KeyPrefix,
-      base_offset: int = 0
+      base_offset: int = 0,
   ) -> ScopesPrefixKey:
     """Decodes the scopes prefix key."""
     offset, key_type = decoder.DecodeUint8()
     if key_type != definitions.GlobalMetadataKeyType.SCOPES_PREFIX:
-      raise errors.ParserError('Not a ScopesPrefixKey')
+      raise errors.ParserError("Not a ScopesPrefixKey")
     return cls(offset=base_offset + offset, key_prefix=key_prefix)
 
 
@@ -630,27 +645,30 @@ class DatabaseFreeListKey(BaseIndexedDBKey):
   Attributes:
     database_id: the database ID.
   """
+
   database_id: int
 
-  def DecodeValue(self, decoder: utils.LevelDBDecoder):
+  def DecodeValue(self, decoder: utils.LevelDBDecoder) -> None:
     """Decodes the database free list value."""
-    raise NotImplementedError('DatabaseFreeListKey.decode_value')
+    raise NotImplementedError("DatabaseFreeListKey.decode_value")
 
   @classmethod
   def FromDecoder(
       cls,
       decoder: utils.LevelDBDecoder,
       key_prefix: KeyPrefix,
-      base_offset: int = 0
+      base_offset: int = 0,
   ) -> DatabaseFreeListKey:
     """Decodes the database free list key."""
     offset, key_type = decoder.DecodeUint8()
     if key_type != definitions.GlobalMetadataKeyType.DATABASE_FREE_LIST:
-      raise errors.ParserError('Not a DatabaseFreeListKey')
+      raise errors.ParserError("Not a DatabaseFreeListKey")
     _, database_id = decoder.DecodeVarint()
     return cls(
-        offset=base_offset + offset, key_prefix=key_prefix,
-        database_id=database_id)
+        offset=base_offset + offset,
+        key_prefix=key_prefix,
+        database_id=database_id,
+    )
 
 
 @dataclass
@@ -661,6 +679,7 @@ class DatabaseNameKey(BaseIndexedDBKey):
     origin: the origin of the database.
     database_name: the database name.
   """
+
   origin: str
   database_name: str
 
@@ -676,45 +695,40 @@ class DatabaseNameKey(BaseIndexedDBKey):
       cls,
       decoder: utils.LevelDBDecoder,
       key_prefix: KeyPrefix,
-      base_offset: int = 0
+      base_offset: int = 0,
   ) -> DatabaseNameKey:
     """Decodes the database name key."""
     offset, key_type = decoder.DecodeUint8()
     if key_type != definitions.GlobalMetadataKeyType.DATABASE_NAME:
-      raise errors.ParserError('Not a DatabaseNameKey')
+      raise errors.ParserError("Not a DatabaseNameKey")
     _, origin = decoder.DecodeStringWithLength()
     _, database_name = decoder.DecodeStringWithLength()
     return cls(
-        offset=base_offset + offset, key_prefix=key_prefix, origin=origin,
-        database_name=database_name)
+        offset=base_offset + offset,
+        key_prefix=key_prefix,
+        origin=origin,
+        database_name=database_name,
+    )
 
 
 @dataclass
 class GlobalMetaDataKey(BaseIndexedDBKey):
   """A GlobalMetaDataKey parser."""
 
+  # pylint: disable=line-too-long
   METADATA_TYPE_TO_CLASS = {
-      definitions.GlobalMetadataKeyType
-          .ACTIVE_BLOB_JOURNAL: ActiveBlobJournalKey,
-      definitions.GlobalMetadataKeyType
-        .DATA_VERSION: DataVersionKey,
-      definitions.GlobalMetadataKeyType
-          .DATABASE_FREE_LIST: DatabaseFreeListKey,
-      definitions.GlobalMetadataKeyType
-          .DATABASE_NAME: DatabaseNameKey,
-      definitions.GlobalMetadataKeyType
-          .EARLIEST_COMPACTION_TIME: EarliestCompactionTimeKey,
-      definitions.GlobalMetadataKeyType
-          .EARLIEST_SWEEP: EarliestSweepKey,
-      definitions.GlobalMetadataKeyType
-          .MAX_DATABASE_ID: MaxDatabaseIdKey,
-      definitions.GlobalMetadataKeyType
-          .RECOVERY_BLOB_JOURNAL: RecoveryBlobJournalKey,
-      definitions.GlobalMetadataKeyType
-          .SCHEMA_VERSION: SchemaVersionKey,
-      definitions.GlobalMetadataKeyType
-          .SCOPES_PREFIX: ScopesPrefixKey,
+      definitions.GlobalMetadataKeyType.ACTIVE_BLOB_JOURNAL: ActiveBlobJournalKey,
+      definitions.GlobalMetadataKeyType.DATA_VERSION: DataVersionKey,
+      definitions.GlobalMetadataKeyType.DATABASE_FREE_LIST: DatabaseFreeListKey,
+      definitions.GlobalMetadataKeyType.DATABASE_NAME: DatabaseNameKey,
+      definitions.GlobalMetadataKeyType.EARLIEST_COMPACTION_TIME: EarliestCompactionTimeKey,
+      definitions.GlobalMetadataKeyType.EARLIEST_SWEEP: EarliestSweepKey,
+      definitions.GlobalMetadataKeyType.MAX_DATABASE_ID: MaxDatabaseIdKey,
+      definitions.GlobalMetadataKeyType.RECOVERY_BLOB_JOURNAL: RecoveryBlobJournalKey,
+      definitions.GlobalMetadataKeyType.SCHEMA_VERSION: SchemaVersionKey,
+      definitions.GlobalMetadataKeyType.SCOPES_PREFIX: ScopesPrefixKey,
   }
+  # pylint: enable=line-too-long
 
   def DecodeValue(self, decoder: utils.LevelDBDecoder) -> Any:
     """Decodes the value from the current position of the LevelDBDecoder.
@@ -728,17 +742,19 @@ class GlobalMetaDataKey(BaseIndexedDBKey):
       cls,
       decoder: utils.LevelDBDecoder,
       key_prefix: KeyPrefix,
-      base_offset: int = 0
-  ) -> Union[ActiveBlobJournalKey,
-             DataVersionKey,
-             DatabaseFreeListKey,
-             DatabaseNameKey,
-             EarliestSweepKey,
-             EarliestCompactionTimeKey,
-             MaxDatabaseIdKey,
-             RecoveryBlobJournalKey,
-             SchemaVersionKey,
-             ScopesPrefixKey]:
+      base_offset: int = 0,
+  ) -> Union[
+      ActiveBlobJournalKey,
+      DataVersionKey,
+      DatabaseFreeListKey,
+      DatabaseNameKey,
+      EarliestSweepKey,
+      EarliestCompactionTimeKey,
+      MaxDatabaseIdKey,
+      RecoveryBlobJournalKey,
+      SchemaVersionKey,
+      ScopesPrefixKey,
+  ]:
     """Decodes the global metadata key.
 
     Raises:
@@ -749,9 +765,10 @@ class GlobalMetaDataKey(BaseIndexedDBKey):
 
     key_class = cls.METADATA_TYPE_TO_CLASS.get(metadata_type)
     if not key_class:
-      raise errors.ParserError('Unknown metadata key type')
-    return key_class.FromDecoder(
-        decoder, key_prefix, base_offset)
+      raise errors.ParserError("Unknown metadata key type")
+    return key_class.FromDecoder(  # type: ignore[attr-defined,no-any-return]
+        decoder, key_prefix, base_offset
+    )
 
 
 @dataclass
@@ -761,27 +778,30 @@ class ObjectStoreFreeListKey(BaseIndexedDBKey):
   Attributes:
     object_store_id: the ID of the object store containing the free list.
   """
+
   object_store_id: int
 
-  def DecodeValue(self, decoder: utils.LevelDBDecoder):
+  def DecodeValue(self, decoder: utils.LevelDBDecoder) -> None:
     """Decodes the object store free list value."""
-    raise NotImplementedError('ObjectStoreFreeListKey.decode_value')
+    raise NotImplementedError("ObjectStoreFreeListKey.decode_value")
 
   @classmethod
   def FromDecoder(
       cls,
       decoder: utils.LevelDBDecoder,
       key_prefix: KeyPrefix,
-      base_offset: int = 0
+      base_offset: int = 0,
   ) -> ObjectStoreFreeListKey:
     """Decodes the object store free list key."""
     offset, key_type = decoder.DecodeUint8()
     if key_type != definitions.DatabaseMetaDataKeyType.OBJECT_STORE_FREE_LIST:
-      raise errors.ParserError('Not am ObjectStoreFreeListKey')
+      raise errors.ParserError("Not am ObjectStoreFreeListKey")
     _, object_store_id = decoder.DecodeVarint()
     return cls(
-        offset=base_offset + offset, key_prefix=key_prefix,
-        object_store_id=object_store_id)
+        offset=base_offset + offset,
+        key_prefix=key_prefix,
+        object_store_id=object_store_id,
+    )
 
 
 @dataclass
@@ -791,27 +811,30 @@ class IndexFreeListKey(BaseIndexedDBKey):
   Attributes:
     object_store_id: the ID of the object store containing the free list.
   """
+
   object_store_id: int
 
-  def DecodeValue(self, decoder: utils.LevelDBDecoder):
+  def DecodeValue(self, decoder: utils.LevelDBDecoder) -> None:
     """Decodes the index free list value."""
-    raise NotImplementedError('IndexFreeListKey.decode_value')
+    raise NotImplementedError("IndexFreeListKey.decode_value")
 
   @classmethod
   def FromDecoder(
       cls,
       decoder: utils.LevelDBDecoder,
       key_prefix: KeyPrefix,
-      base_offset: int = 0
-    ) -> IndexFreeListKey:
+      base_offset: int = 0,
+  ) -> IndexFreeListKey:
     """Decodes the index free list key."""
     offset, key_type = decoder.DecodeUint8()
     if key_type != definitions.DatabaseMetaDataKeyType.INDEX_FREE_LIST:
-      raise errors.ParserError('Not am IndexFreeListKey')
+      raise errors.ParserError("Not am IndexFreeListKey")
     _, object_store_id = decoder.DecodeVarint()
     return cls(
-        offset=base_offset + offset, key_prefix=key_prefix,
-        object_store_id=object_store_id)
+        offset=base_offset + offset,
+        key_prefix=key_prefix,
+        object_store_id=object_store_id,
+    )
 
 
 @dataclass
@@ -821,6 +844,7 @@ class ObjectStoreNamesKey(BaseIndexedDBKey):
   Attributes:
     object_store_name: the name of the object store.
   """
+
   object_store_name: str
 
   def DecodeValue(self, decoder: utils.LevelDBDecoder) -> int:
@@ -829,17 +853,21 @@ class ObjectStoreNamesKey(BaseIndexedDBKey):
 
   @classmethod
   def FromDecoder(
-      cls, decoder: utils.LevelDBDecoder,
+      cls,
+      decoder: utils.LevelDBDecoder,
       key_prefix: KeyPrefix,
-      base_offset: int = 0
+      base_offset: int = 0,
   ) -> ObjectStoreNamesKey:
     """Decodes the object store names key."""
     offset, key_type = decoder.DecodeUint8()
     if key_type != definitions.DatabaseMetaDataKeyType.OBJECT_STORE_NAMES:
-      raise errors.ParserError('Not am ObjectStoreNamesKey')
+      raise errors.ParserError("Not am ObjectStoreNamesKey")
     _, object_store_name = decoder.DecodeStringWithLength()
-    return cls(key_prefix=key_prefix, offset=base_offset + offset,
-               object_store_name=object_store_name)
+    return cls(
+        key_prefix=key_prefix,
+        offset=base_offset + offset,
+        object_store_name=object_store_name,
+    )
 
 
 @dataclass
@@ -849,6 +877,7 @@ class IndexNamesKey(BaseIndexedDBKey):
   Attributes:
     index_name: the name of the index.
   """
+
   index_name: str
 
   def DecodeValue(self, decoder: utils.LevelDBDecoder) -> int:
@@ -860,15 +889,18 @@ class IndexNamesKey(BaseIndexedDBKey):
       cls,
       decoder: utils.LevelDBDecoder,
       key_prefix: KeyPrefix,
-      base_offset: int = 0
+      base_offset: int = 0,
   ) -> IndexNamesKey:
     """Decodes the index names key."""
     offset, key_type = decoder.DecodeUint8()
     if key_type != definitions.DatabaseMetaDataKeyType.INDEX_NAMES:
-      raise errors.ParserError('Not am IndexNamesKey')
+      raise errors.ParserError("Not am IndexNamesKey")
     _, index_name = decoder.DecodeStringWithLength()
-    return cls(key_prefix=key_prefix, offset=base_offset + offset,
-               index_name=index_name)
+    return cls(
+        key_prefix=key_prefix,
+        offset=base_offset + offset,
+        index_name=index_name,
+    )
 
 
 @dataclass
@@ -878,39 +910,45 @@ class DatabaseMetaDataKey(BaseIndexedDBKey):
   Attributes:
     metadata_type: the type of metadata that the key value contains.
   """
+
   metadata_type: definitions.DatabaseMetaDataKeyType
 
-  def DecodeValue(
-      self, decoder: utils.LevelDBDecoder) -> Union[str, int]:
+  def DecodeValue(self, decoder: utils.LevelDBDecoder) -> Union[str, int]:
     """Decodes the database metadata value."""
-    if (self.metadata_type ==
-        definitions.DatabaseMetaDataKeyType.ORIGIN_NAME):
+    if self.metadata_type == definitions.DatabaseMetaDataKeyType.ORIGIN_NAME:
       return decoder.DecodeString()[1]
-    if (self.metadata_type ==
-        definitions.DatabaseMetaDataKeyType.DATABASE_NAME):
+    if self.metadata_type == definitions.DatabaseMetaDataKeyType.DATABASE_NAME:
       return decoder.DecodeString()[1]
-    if (self.metadata_type ==
-        definitions.DatabaseMetaDataKeyType.IDB_STRING_VERSION_DATA):
+    if (
+        self.metadata_type
+        == definitions.DatabaseMetaDataKeyType.IDB_STRING_VERSION_DATA
+    ):
       return decoder.DecodeString()[1]
-    if (self.metadata_type ==
-        definitions.DatabaseMetaDataKeyType.MAX_ALLOCATED_OBJECT_STORE_ID):
+    if (
+        self.metadata_type
+        == definitions.DatabaseMetaDataKeyType.MAX_ALLOCATED_OBJECT_STORE_ID
+    ):
       return decoder.DecodeInt()[1]
-    if (self.metadata_type ==
-        definitions.DatabaseMetaDataKeyType.IDB_INTEGER_VERSION):
+    if (
+        self.metadata_type
+        == definitions.DatabaseMetaDataKeyType.IDB_INTEGER_VERSION
+    ):
       return decoder.DecodeVarint()[1]
-    if (self.metadata_type ==
-        definitions.DatabaseMetaDataKeyType
-            .BLOB_NUMBER_GENERATOR_CURRENT_NUMBER):
+    if (
+        self.metadata_type
+        == definitions.DatabaseMetaDataKeyType.BLOB_NUMBER_GENERATOR_CURRENT_NUMBER  # pylint: disable=line-too-long
+    ):
       return decoder.DecodeVarint()[1]
     raise errors.ParserError(
-        f'Unknown database metadata type {self.metadata_type}')
+        f"Unknown database metadata type {self.metadata_type}"
+    )
 
   @classmethod
   def FromDecoder(
       cls,
       decoder: utils.LevelDBDecoder,
       key_prefix: KeyPrefix,
-      base_offset: int = 0
+      base_offset: int = 0,
   ) -> Union[
       DatabaseMetaDataKey,
       IndexFreeListKey,
@@ -918,7 +956,8 @@ class DatabaseMetaDataKey(BaseIndexedDBKey):
       IndexNamesKey,
       ObjectStoreFreeListKey,
       ObjectStoreMetaDataKey,
-      ObjectStoreNamesKey]:
+      ObjectStoreNamesKey,
+  ]:
     """Decodes the database metadata key."""
     offset, metadata_value = decoder.PeekBytes(1)
     metadata_type = definitions.DatabaseMetaDataKeyType(metadata_value[0])
@@ -929,32 +968,36 @@ class DatabaseMetaDataKey(BaseIndexedDBKey):
         definitions.DatabaseMetaDataKeyType.IDB_STRING_VERSION_DATA,
         definitions.DatabaseMetaDataKeyType.MAX_ALLOCATED_OBJECT_STORE_ID,
         definitions.DatabaseMetaDataKeyType.IDB_INTEGER_VERSION,
-        definitions.DatabaseMetaDataKeyType
-            .BLOB_NUMBER_GENERATOR_CURRENT_NUMBER):
-      return cls(key_prefix=key_prefix, offset=base_offset + offset,
-                 metadata_type=metadata_type)
+        definitions.DatabaseMetaDataKeyType.BLOB_NUMBER_GENERATOR_CURRENT_NUMBER,  # pylint: disable=line-too-long
+    ):
+      return cls(
+          key_prefix=key_prefix,
+          offset=base_offset + offset,
+          metadata_type=metadata_type,
+      )
     if metadata_type == definitions.DatabaseMetaDataKeyType.INDEX_META_DATA:
-      return IndexMetaDataKey.FromDecoder(
-          decoder, key_prefix, base_offset)
-    if (metadata_type ==
-        definitions.DatabaseMetaDataKeyType.OBJECT_STORE_META_DATA):
+      return IndexMetaDataKey.FromDecoder(decoder, key_prefix, base_offset)
+    if (
+        metadata_type
+        == definitions.DatabaseMetaDataKeyType.OBJECT_STORE_META_DATA
+    ):
       return ObjectStoreMetaDataKey.FromDecoder(
-          decoder, key_prefix, base_offset)
-    if (metadata_type ==
-        definitions.DatabaseMetaDataKeyType.OBJECT_STORE_FREE_LIST):
+          decoder, key_prefix, base_offset
+      )
+    if (
+        metadata_type
+        == definitions.DatabaseMetaDataKeyType.OBJECT_STORE_FREE_LIST
+    ):
       return ObjectStoreFreeListKey.FromDecoder(
-          decoder, key_prefix, base_offset)
+          decoder, key_prefix, base_offset
+      )
     if metadata_type == definitions.DatabaseMetaDataKeyType.INDEX_FREE_LIST:
-      return IndexFreeListKey.FromDecoder(
-          decoder, key_prefix, base_offset)
-    if (metadata_type ==
-        definitions.DatabaseMetaDataKeyType.OBJECT_STORE_NAMES):
-      return ObjectStoreNamesKey.FromDecoder(
-          decoder, key_prefix, base_offset)
+      return IndexFreeListKey.FromDecoder(decoder, key_prefix, base_offset)
+    if metadata_type == definitions.DatabaseMetaDataKeyType.OBJECT_STORE_NAMES:
+      return ObjectStoreNamesKey.FromDecoder(decoder, key_prefix, base_offset)
     if metadata_type == definitions.DatabaseMetaDataKeyType.INDEX_NAMES:
-      return IndexNamesKey.FromDecoder(
-          decoder, key_prefix, base_offset)
-    raise errors.ParserError(f'unknown database metadata type {metadata_type}.')
+      return IndexNamesKey.FromDecoder(decoder, key_prefix, base_offset)
+    raise errors.ParserError(f"unknown database metadata type {metadata_type}.")
 
 
 @dataclass
@@ -965,58 +1008,78 @@ class ObjectStoreMetaDataKey(BaseIndexedDBKey):
     object_store_id: the ID of the object store.
     metadata_type: the object store metadata type.
   """
+
   object_store_id: int
   metadata_type: definitions.ObjectStoreMetaDataKeyType
 
   def DecodeValue(
-      self,
-      decoder: utils.LevelDBDecoder
+      self, decoder: utils.LevelDBDecoder
   ) -> Union[IDBKeyPath, str, bool, int]:
     """Decodes the object store metadata value."""
-    if (self.metadata_type ==
-        definitions.ObjectStoreMetaDataKeyType.OBJECT_STORE_NAME):
+    if (
+        self.metadata_type
+        == definitions.ObjectStoreMetaDataKeyType.OBJECT_STORE_NAME
+    ):
       return decoder.DecodeString()[1]
     if self.metadata_type == definitions.ObjectStoreMetaDataKeyType.KEY_PATH:
       return IDBKeyPath.FromDecoder(decoder)
-    if (self.metadata_type ==
-        definitions.ObjectStoreMetaDataKeyType.AUTO_INCREMENT_FLAG):
+    if (
+        self.metadata_type
+        == definitions.ObjectStoreMetaDataKeyType.AUTO_INCREMENT_FLAG
+    ):
       return decoder.DecodeBool()[1]
-    if (self.metadata_type ==
-        definitions.ObjectStoreMetaDataKeyType.IS_EVICTABLE):
+    if (
+        self.metadata_type
+        == definitions.ObjectStoreMetaDataKeyType.IS_EVICTABLE
+    ):
       return decoder.DecodeBool()[1]
-    if (self.metadata_type ==
-        definitions.ObjectStoreMetaDataKeyType.LAST_VERSION_NUMBER):
+    if (
+        self.metadata_type
+        == definitions.ObjectStoreMetaDataKeyType.LAST_VERSION_NUMBER
+    ):
       return decoder.DecodeInt(signed=False)[1]
-    if (self.metadata_type ==
-        definitions.ObjectStoreMetaDataKeyType.MAXIMUM_ALLOCATED_INDEX_ID):
+    if (
+        self.metadata_type
+        == definitions.ObjectStoreMetaDataKeyType.MAXIMUM_ALLOCATED_INDEX_ID
+    ):
       return decoder.DecodeInt()[1]
-    if (self.metadata_type ==
-        definitions.ObjectStoreMetaDataKeyType.HAS_KEY_PATH):
+    if (
+        self.metadata_type
+        == definitions.ObjectStoreMetaDataKeyType.HAS_KEY_PATH
+    ):
       return decoder.DecodeBool()[1]
-    if (self.metadata_type ==
-        definitions.ObjectStoreMetaDataKeyType.KEY_GENERATOR_CURRENT_NUMBER):
+    if (
+        self.metadata_type
+        == definitions.ObjectStoreMetaDataKeyType.KEY_GENERATOR_CURRENT_NUMBER
+    ):
       return decoder.DecodeInt()[1]
-    raise errors.ParserError(f'Unknown metadata type {self.metadata_type}')
+    raise errors.ParserError(f"Unknown metadata type {self.metadata_type}")
 
   @classmethod
   def FromDecoder(
       cls,
       decoder: utils.LevelDBDecoder,
       key_prefix: KeyPrefix,
-      base_offset: int = 0
+      base_offset: int = 0,
   ) -> ObjectStoreMetaDataKey:
     """Decodes the object store metadata key."""
     offset, metadata_value = decoder.DecodeUint8()
-    if (metadata_value !=
-        definitions.DatabaseMetaDataKeyType.OBJECT_STORE_META_DATA):
-      raise errors.ParserError('Not a ObjectStoreMetaDataKey')
+    if (
+        metadata_value
+        != definitions.DatabaseMetaDataKeyType.OBJECT_STORE_META_DATA
+    ):
+      raise errors.ParserError("Not a ObjectStoreMetaDataKey")
 
     _, object_store_id = decoder.DecodeVarint()
     _, metadata_value = decoder.DecodeUint8()
     metadata_type = definitions.ObjectStoreMetaDataKeyType(metadata_value)
     return cls(
-        offset=base_offset + offset, key_prefix=key_prefix,
-        object_store_id=object_store_id, metadata_type=metadata_type)
+        offset=base_offset + offset,
+        key_prefix=key_prefix,
+        object_store_id=object_store_id,
+        metadata_type=metadata_type,
+    )
+
 
 @dataclass
 class ObjectStoreDataValue:
@@ -1024,13 +1087,12 @@ class ObjectStoreDataValue:
 
   Attributes:
     version: the version prefix.
-    is_wrapped: True if the value was wrapped.
     blob_size: the blob size, only valid if wrapped.
     blob_offset: the blob offset, only valid if wrapped.
     value: the blink serialized value, only valid if not wrapped.
   """
+
   version: int
-  is_wrapped: bool
   blob_size: Optional[int]
   blob_offset: Optional[int]
   value: Any
@@ -1043,68 +1105,59 @@ class ObjectStoreDataKey(BaseIndexedDBKey):
   Attributes:
     encoded_user_key: the encoded user key.
   """
+
   encoded_user_key: IDBKey
 
-  def DecodeValue(
-      self,
-      decoder: utils.LevelDBDecoder
-  ) -> ObjectStoreDataValue:
+  def DecodeValue(self, decoder: utils.LevelDBDecoder) -> ObjectStoreDataValue:
     """Decodes the object store data value."""
     _, version = decoder.DecodeVarint()
 
     _, wrapped_header_bytes = decoder.PeekBytes(3)
     if len(wrapped_header_bytes) != 3:
-      raise errors.DecoderError('Insufficient bytes')
+      raise errors.DecoderError("Insufficient bytes")
 
-    if (wrapped_header_bytes[0] ==
-            definitions.BlinkSerializationTag.VERSION and
-        wrapped_header_bytes[1] ==
-            definitions.REQUIRES_PROCESSING_SSV_PSEUDO_VERSION and
-        wrapped_header_bytes[2] == definitions.REPLACE_WITH_BLOB):
+    if (
+        wrapped_header_bytes[0] == definitions.BlinkSerializationTag.VERSION
+        and wrapped_header_bytes[1]
+        == definitions.REQUIRES_PROCESSING_SSV_PSEUDO_VERSION
+        and wrapped_header_bytes[2] == definitions.REPLACE_WITH_BLOB
+    ):
       _ = decoder.ReadBytes(3)
       _, blob_size = decoder.DecodeVarint()
       _, blob_offset = decoder.DecodeVarint()
       return ObjectStoreDataValue(
           version=version,
-          is_wrapped=True,
           blob_size=blob_size,
           blob_offset=blob_offset,
-          value=None)
+          value=None,
+      )
+
     _, blink_bytes = decoder.ReadBytes()
-    is_wrapped = False
-    if (
-        wrapped_header_bytes[0] ==
-        definitions.BlinkSerializationTag.VERSION and
-        wrapped_header_bytes[1] ==
-        definitions.REQUIRES_PROCESSING_SSV_PSEUDO_VERSION and
-        wrapped_header_bytes[2] == definitions.COMPRESSED_WITH_SNAPPY):
-      is_wrapped = True
-      # ignore the wrapped header bytes when decompressing
-      blink_bytes = snappy.decompress(blink_bytes[3:])
     blink_value = blink.V8ScriptValueDecoder.FromBytes(blink_bytes)
     return ObjectStoreDataValue(
-        version=version,
-        is_wrapped=is_wrapped,
-        blob_size=None,
-        blob_offset=None,
-        value=blink_value)
+        version=version, blob_size=None, blob_offset=None, value=blink_value
+    )
 
   @classmethod
   def FromDecoder(
       cls,
       decoder: utils.LevelDBDecoder,
       key_prefix: KeyPrefix,
-      base_offset: int = 0
+      base_offset: int = 0,
   ) -> ObjectStoreDataKey:
     """Decodes the object store data key."""
-    if (key_prefix.GetKeyPrefixType() !=
-        definitions.KeyPrefixType.OBJECT_STORE_DATA):
-      raise errors.ParserError('Invalid KeyPrefix for ObjectStoreDataKey')
+    if (
+        key_prefix.GetKeyPrefixType()
+        != definitions.KeyPrefixType.OBJECT_STORE_DATA
+    ):
+      raise errors.ParserError("Invalid KeyPrefix for ObjectStoreDataKey")
     offset = decoder.stream.tell()
     encoded_user_key = IDBKey.FromDecoder(decoder, offset)
     return cls(
         offset=base_offset + offset,
-        key_prefix=key_prefix, encoded_user_key=encoded_user_key)
+        key_prefix=key_prefix,
+        encoded_user_key=encoded_user_key,
+    )
 
 
 @dataclass
@@ -1114,26 +1167,29 @@ class ExistsEntryKey(BaseIndexedDBKey):
   Attributes:
     encoded_user_key: the encoded user key.
   """
+
   encoded_user_key: IDBKey
 
   def DecodeValue(self, decoder: utils.LevelDBDecoder) -> int:
     """Decodes the exists entry value."""
     _, data = decoder.ReadBytes()
-    return int.from_bytes(data, byteorder='little', signed=False)
+    return int.from_bytes(data, byteorder="little", signed=False)
 
   @classmethod
   def FromDecoder(
       cls,
       decoder: utils.LevelDBDecoder,
       key_prefix: KeyPrefix,
-      base_offset: int = 0
+      base_offset: int = 0,
   ) -> ExistsEntryKey:
     """Decodes the exists entry key."""
     offset = decoder.stream.tell()
     encoded_user_key = IDBKey.FromDecoder(decoder, offset)
     return cls(
         offset=base_offset + offset,
-        key_prefix=key_prefix, encoded_user_key=encoded_user_key)
+        key_prefix=key_prefix,
+        encoded_user_key=encoded_user_key,
+    )
 
 
 @dataclass
@@ -1145,6 +1201,7 @@ class IndexDataKey(BaseIndexedDBKey):
     sequence_number: the sequence number of the data key.
     encoded_primary_key: the encoded primary key.
   """
+
   encoded_user_key: IDBKey
   sequence_number: Optional[int]
   encoded_primary_key: Optional[IDBKey]
@@ -1160,7 +1217,7 @@ class IndexDataKey(BaseIndexedDBKey):
       cls,
       decoder: utils.LevelDBDecoder,
       key_prefix: KeyPrefix,
-      base_offset: int = 0
+      base_offset: int = 0,
   ) -> IndexDataKey:
     """Decodes the index data key."""
     offset = decoder.stream.tell()
@@ -1174,7 +1231,8 @@ class IndexDataKey(BaseIndexedDBKey):
     if decoder.NumRemainingBytes() > 0:
       encoded_primary_key_offset = decoder.stream.tell()
       encoded_primary_key = IDBKey.FromDecoder(
-          decoder, encoded_primary_key_offset)
+          decoder, encoded_primary_key_offset
+      )
     else:
       encoded_primary_key = None
 
@@ -1183,7 +1241,8 @@ class IndexDataKey(BaseIndexedDBKey):
         encoded_user_key=encoded_user_key,
         sequence_number=sequence_number,
         encoded_primary_key=encoded_primary_key,
-        offset=base_offset + offset)
+        offset=base_offset + offset,
+    )
 
 
 @dataclass
@@ -1193,11 +1252,11 @@ class BlobEntryKey(BaseIndexedDBKey):
   Attributes:
     user_key: the user/primary key.
   """
+
   user_key: IDBKey
 
   def DecodeValue(
-      self,
-      decoder: utils.LevelDBDecoder
+      self, decoder: utils.LevelDBDecoder
   ) -> IndexedDBExternalObject:
     """Decodes the blob entry value."""
     return IndexedDBExternalObject.FromDecoder(decoder)
@@ -1207,14 +1266,15 @@ class BlobEntryKey(BaseIndexedDBKey):
       cls,
       decoder: utils.LevelDBDecoder,
       key_prefix: KeyPrefix,
-      base_offset: int = 0
+      base_offset: int = 0,
   ) -> BlobEntryKey:
     """Decodes the blob entry key."""
     offset = decoder.stream.tell()
     user_key = IDBKey.FromDecoder(decoder, offset)
 
-    return cls(key_prefix=key_prefix, user_key=user_key,
-               offset=base_offset + offset)
+    return cls(
+        key_prefix=key_prefix, user_key=user_key, offset=base_offset + offset
+    )
 
 
 @dataclass
@@ -1246,23 +1306,25 @@ class IndexedDbKey(BaseIndexedDBKey):
       cls,
       decoder: utils.LevelDBDecoder,
       key_prefix: KeyPrefix,
-      base_offset: int = 0
+      base_offset: int = 0,
   ) -> Union[
       BlobEntryKey,
       DatabaseMetaDataKey,
       ExistsEntryKey,
       GlobalMetaDataKey,
       IndexDataKey,
-      ObjectStoreDataKey]:
+      ObjectStoreDataKey,
+  ]:
     """Decodes the IndexedDB key."""
     key_type = key_prefix.GetKeyPrefixType()
     key_class = cls.METADATA_TYPE_TO_CLASS.get(key_type)
     if not key_class:
-      raise errors.ParserError('Unknown KeyPrefixType')
+      raise errors.ParserError("Unknown KeyPrefixType")
     return key_class.FromDecoder(
         decoder=decoder,
-        key_prefix=key_prefix,  #pytype: disable=bad-return-type
-        base_offset=base_offset)
+        key_prefix=key_prefix,  # type: ignore[return-value]
+        base_offset=base_offset,
+    )
 
 
 @dataclass
@@ -1274,45 +1336,49 @@ class IndexMetaDataKey(BaseIndexedDBKey):
     index_id: the index ID.
     metadata_type: the metadata key type.
   """
+
   object_store_id: int
   index_id: int
   metadata_type: definitions.IndexMetaDataKeyType
 
   def DecodeValue(
-      self,
-      decoder: utils.LevelDBDecoder
+      self, decoder: utils.LevelDBDecoder
   ) -> Union[bool, IDBKeyPath, str]:
     """Decodes the index metadata value."""
     if self.metadata_type == definitions.IndexMetaDataKeyType.INDEX_NAME:
       return decoder.DecodeString()[1]
     if self.metadata_type == definitions.IndexMetaDataKeyType.KEY_PATH:
       return IDBKeyPath.FromDecoder(decoder)
-    if (self.metadata_type ==
-        definitions.IndexMetaDataKeyType.MULTI_ENTRY_FLAG):
+    if self.metadata_type == definitions.IndexMetaDataKeyType.MULTI_ENTRY_FLAG:
       return decoder.DecodeBool()[1]
     if self.metadata_type == definitions.IndexMetaDataKeyType.UNIQUE_FLAG:
       return decoder.DecodeBool()[1]
     raise errors.ParserError(
-        f'Unknown index metadata type {self.metadata_type}')
+        f"Unknown index metadata type {self.metadata_type}"
+    )
 
   @classmethod
   def FromDecoder(
       cls,
       decoder: utils.LevelDBDecoder,
       key_prefix: KeyPrefix,
-      base_offset: int = 0
+      base_offset: int = 0,
   ) -> IndexMetaDataKey:
     """Decodes the index metadata key."""
     offset, key_type = decoder.DecodeUint8()
     if key_type != definitions.DatabaseMetaDataKeyType.INDEX_META_DATA:
-      raise errors.ParserError('Not an IndexMetaDataKey.')
+      raise errors.ParserError("Not an IndexMetaDataKey.")
     _, object_store_id = decoder.DecodeVarint()
     _, index_id = decoder.DecodeVarint()
     _, metadata_bytes = decoder.ReadBytes(1)
     metadata_type = definitions.IndexMetaDataKeyType(metadata_bytes[0])
-    return cls(offset=base_offset + offset, key_prefix=key_prefix,
-               object_store_id=object_store_id, index_id=index_id,
-               metadata_type=metadata_type)
+    return cls(
+        offset=base_offset + offset,
+        key_prefix=key_prefix,
+        object_store_id=object_store_id,
+        index_id=index_id,
+        metadata_type=metadata_type,
+    )
 
 
 @dataclass
@@ -1331,6 +1397,7 @@ class ExternalObjectEntry(utils.FromDecoderMixin):
     last_modified: the last modified time if a blob or file, None otherwise.
     token: the token if a filesystem access handle, None otherwise.
   """
+
   offset: int = field(compare=False)
   object_type: definitions.ExternalObjectType
   blob_number: Optional[int]
@@ -1342,16 +1409,15 @@ class ExternalObjectEntry(utils.FromDecoderMixin):
 
   @classmethod
   def FromDecoder(
-      cls,
-      decoder: utils.LevelDBDecoder,
-      base_offset: int = 0
+      cls, decoder: utils.LevelDBDecoder, base_offset: int = 0
   ) -> ExternalObjectEntry:
     """Decodes the external object entry."""
     offset, object_type_value = decoder.DecodeUint8()
     object_type = definitions.ExternalObjectType(object_type_value)
-    if (object_type in
-        (definitions.ExternalObjectType.BLOB,
-         definitions.ExternalObjectType.FILE)):
+    if object_type in (
+        definitions.ExternalObjectType.BLOB,
+        definitions.ExternalObjectType.FILE,
+    ):
       _, blob_number = decoder.DecodeVarint()
       _, mime_type = decoder.DecodeStringWithLength()
       _, size = decoder.DecodeVarint()
@@ -1363,8 +1429,10 @@ class ExternalObjectEntry(utils.FromDecoderMixin):
         last_modified = None
       token = None
     else:
-      if (object_type ==
-          definitions.ExternalObjectType.FILE_SYSTEM_ACCESS_HANDLE):
+      if (
+          object_type
+          == definitions.ExternalObjectType.FILE_SYSTEM_ACCESS_HANDLE
+      ):
         _, token = decoder.DecodeBlobWithLength()
       else:
         token = None
@@ -1374,9 +1442,16 @@ class ExternalObjectEntry(utils.FromDecoderMixin):
       filename = None
       last_modified = None
 
-    return cls(offset=base_offset + offset, object_type=object_type,
-        blob_number=blob_number, mime_type=mime_type, size=size,
-        filename=filename, last_modified=last_modified, token=token)
+    return cls(
+        offset=base_offset + offset,
+        object_type=object_type,
+        blob_number=blob_number,
+        mime_type=mime_type,
+        size=size,
+        filename=filename,
+        last_modified=last_modified,
+        token=token,
+    )
 
 
 @dataclass
@@ -1387,14 +1462,13 @@ class IndexedDBExternalObject(utils.FromDecoderMixin):
     offset: the offset of the IndexedDBExternalObject.
     entries: a list of external objects.
   """
+
   offset: int = field(compare=False)
   entries: list[ExternalObjectEntry]
 
   @classmethod
   def FromDecoder(
-      cls,
-      decoder: utils.LevelDBDecoder,
-      base_offset: int = 0
+      cls, decoder: utils.LevelDBDecoder, base_offset: int = 0
   ) -> IndexedDBExternalObject:
     """Decodes the external object."""
     entries = []
@@ -1406,20 +1480,6 @@ class IndexedDBExternalObject(utils.FromDecoderMixin):
     return cls(offset=base_offset + offset, entries=entries)
 
 
-@dataclass
-class ObjectStore:
-  """An IndexedDB Object Store.
-
-  Attributes:
-    id: the object store ID.
-    name: the object store name.
-    records: the records in the object store.
-  """
-  id: int
-  name: str
-  records: list = field(default_factory=list, repr=False)
-
-
 @dataclass
 class IndexedDBRecord:
   """An IndexedDB Record.
@@ -1434,7 +1494,15 @@ class IndexedDBRecord:
     level: the leveldb level, if applicable, None can indicate the record
         originated from a log file or the level could not be determined.
     recovered: True if the record is a recovered record.
+    database_id: the database ID.
+    object_store_id: the object store ID.
+    database_name: the name of the database, if available.
+    object_store_name: the name of the object store, if available.
+    blob: the blob contents, if available.
+    raw_key: the raw key, if available.
+    raw_value: the raw value, if available.
   """
+
   path: str
   offset: int
   key: Any
@@ -1443,46 +1511,70 @@ class IndexedDBRecord:
   type: int
   level: Optional[int]
   recovered: Optional[bool]
+  database_id: int
+  object_store_id: int
+  database_name: Optional[str] = None
+  object_store_name: Optional[str] = None
+  blob: Optional[bytes] = None
+  raw_key: Optional[bytes] = None
+  raw_value: Optional[bytes] = None
 
   @classmethod
   def FromLevelDBRecord(
-      cls,
-      db_record: record.LevelDBRecord
+      cls, db_record: record.LevelDBRecord, parse_value: bool = True
   ) -> IndexedDBRecord:
     """Returns an IndexedDBRecord from a ParsedInternalKey."""
     idb_key = IndexedDbKey.FromBytes(
-        db_record.record.key, base_offset=db_record.record.offset)
-    idb_value = idb_key.ParseValue(db_record.record.value)
+        db_record.record.key, base_offset=db_record.record.offset
+    )
+
+    if parse_value:
+      idb_value = idb_key.ParseValue(db_record.record.value)
+    else:
+      idb_value = None
+
     return cls(
         path=db_record.path,
         offset=db_record.record.offset,
         key=idb_key,
         value=idb_value,
-        sequence_number=db_record.record.sequence_number if hasattr(
-            db_record.record, 'sequence_number') else None,
+        sequence_number=db_record.record.sequence_number
+        if hasattr(db_record.record, "sequence_number")
+        else None,
         type=db_record.record.record_type,
         level=db_record.level,
-        recovered=db_record.recovered)
+        recovered=db_record.recovered,
+        database_id=idb_key.key_prefix.database_id,
+        object_store_id=idb_key.key_prefix.object_store_id,
+        database_name=None,
+        object_store_name=None,
+        blob=None,
+        raw_key=db_record.record.key,
+        raw_value=db_record.record.value,
+    )
 
   @classmethod
   def FromFile(
-      cls,
-      file_path: pathlib.Path
+      cls, file_path: pathlib.Path, parse_value: bool = True
   ) -> Generator[IndexedDBRecord, None, None]:
     """Yields IndexedDBRecords from a file."""
     for db_record in record.LevelDBRecord.FromFile(file_path):
       try:
-        yield cls.FromLevelDBRecord(db_record)
-      except(
+        yield cls.FromLevelDBRecord(db_record, parse_value=parse_value)
+      except (
           errors.ParserError,
           errors.DecoderError,
-          NotImplementedError) as err:
-        print((
-            'Error parsing Indexeddb record: '
-            f'{err} at offset {db_record.record.offset} in '
-            f'{db_record.path}'),
-            file=sys.stderr)
-        print(f'Traceback: {traceback.format_exc()}', file=sys.stderr)
+          NotImplementedError,
+      ) as err:
+        print(
+            (
+                "Error parsing Indexeddb record: "
+                f"{err} at offset {db_record.record.offset} in "
+                f"{db_record.path}"
+            ),
+            file=sys.stderr,
+        )
+        print(f"Traceback: {traceback.format_exc()}", file=sys.stderr)
 
 
 class FolderReader:
@@ -1502,13 +1594,14 @@ class FolderReader:
       ValueError: if folder_name is None or not a directory.
     """
     if not folder_name or not folder_name.is_dir():
-      raise ValueError(f'{folder_name} is None or not a directory')
+      raise ValueError(f"{folder_name} is None or not a directory")
     self.folder_name = folder_name
 
   def GetRecords(
       self,
       use_manifest: bool = False,
-      use_sequence_number: bool = False
+      use_sequence_number: bool = False,
+      parse_value: bool = True,
   ) -> Generator[IndexedDBRecord, None, None]:
     """Yield LevelDBRecords.
 
@@ -1516,22 +1609,31 @@ class FolderReader:
       use_manifest: True to use the current manifest in the folder as a means to
           find the active file set.
       use_sequence_number: True to use the sequence number to determine the
+          recovered field.
+      parse_value: True to parse values.
+
     Yields:
       IndexedDBRecord.
     """
     leveldb_folder_reader = record.FolderReader(self.folder_name)
     for leveldb_record in leveldb_folder_reader.GetRecords(
-        use_manifest=use_manifest,
-        use_sequence_number=use_sequence_number):
+        use_manifest=use_manifest, use_sequence_number=use_sequence_number
+    ):
       try:
-        yield IndexedDBRecord.FromLevelDBRecord(leveldb_record)
-      except(
+        yield IndexedDBRecord.FromLevelDBRecord(
+            leveldb_record, parse_value=parse_value
+        )
+      except (
           errors.ParserError,
           errors.DecoderError,
-          NotImplementedError) as err:
-        print((
-            'Error parsing Indexeddb record: '
-            f'{err} at offset {leveldb_record.record.offset} in '
-            f'{leveldb_record.path}'),
-            file=sys.stderr)
-        print(f'Traceback: {traceback.format_exc()}', file=sys.stderr)
+          NotImplementedError,
+      ) as err:
+        print(
+            (
+                "Error parsing Indexeddb record: "
+                f"{err} at offset {leveldb_record.record.offset} in "
+                f"{leveldb_record.path}"
+            ),
+            file=sys.stderr,
+        )
+        print(f"Traceback: {traceback.format_exc()}", file=sys.stderr)