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

dfindexeddb/indexeddb/chromium/record.py

@@ -14,26 +14,32 @@
 # limitations under the License.
 """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
+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.
 
@@ -43,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
@@ -50,7 +57,8 @@ class KeyPrefix(utils.FromDecoderMixin):
 
   @classmethod
   def FromDecoder(
-      cls, decoder: utils.LevelDBDecoder, base_offset: int = 0) -> KeyPrefix:
+      cls, decoder: utils.LevelDBDecoder, base_offset: int = 0
+  ) -> KeyPrefix:
     """Decodes a KeyPrefix from the current position of a LevelDBDecoder.
 
     Args:
@@ -71,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.
@@ -110,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
@@ -122,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
 
@@ -132,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.
 
@@ -149,9 +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:
@@ -167,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)
@@ -188,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)
@@ -210,13 +226,15 @@ 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) -> IDBKeyPath:
+  def FromDecoder(
+      cls, decoder: utils.LevelDBDecoder, base_offset: int = 0
+  ) -> IDBKeyPath:
     """Decodes an IDBKeyPath from the current position of a LevelDBDecoder.
 
     Args:
@@ -228,13 +246,15 @@ class IDBKeyPath(utils.FromDecoderMixin):
 
     Raises:
       ParserError: on insufficient bytes or invalid array length during
-        parsing.
+        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.")
+
+    value: str | list[str] | None = None
 
-    if buffer[0:2] != b'\x00\x00':
+    if buffer[0:2] != b"\x00\x00":
       offset, value = decoder.DecodeString()
       return IDBKeyPath(offset, definitions.IDBKeyPathType.STRING, value)
 
@@ -251,10 +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}.")
     return IDBKeyPath(base_offset + offset, key_path_type, value)
 
 
@@ -267,13 +289,15 @@ 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) -> BlobJournalEntry:
+  def FromDecoder(
+      cls, decoder: utils.LevelDBDecoder, base_offset: int = 0
+  ) -> BlobJournalEntry:
     """Decodes a BlobJournalEntry from the current position of a LevelDBDecoder.
 
     Args:
@@ -285,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
@@ -297,12 +324,14 @@ 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) -> BlobJournal:
+  def FromDecoder(
+      cls, decoder: utils.LevelDBDecoder, base_offset: int = 0
+  ) -> BlobJournal:
     """Decodes a BlobJournal from the current position of a LevelDBDecoder.
 
     Blob journals are zero-or-more instances of BlobJournalEntry.  There is no
@@ -342,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
 
@@ -356,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.
@@ -374,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:
@@ -392,11 +422,10 @@ 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:
+  def FromStream(cls: Type[T], stream: BinaryIO, base_offset: int = 0) -> T:
     """Parses the key from the current position of the binary stream.
 
     Args:
@@ -408,12 +437,12 @@ 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:
+  def FromBytes(cls: Type[T], raw_data: bytes, base_offset: int = 0) -> T:
     """Parses the key from the raw key bytes.
 
     Args:
@@ -424,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
@@ -433,17 +464,19 @@ class SchemaVersionKey(BaseIndexedDBKey):
 
   def DecodeValue(self, decoder: utils.LevelDBDecoder) -> int:
     """Decodes the schema version value."""
-    return decoder.DecodeVarint()[1]
+    return decoder.DecodeInt()[1]
 
   @classmethod
   def FromDecoder(
-      cls, decoder: utils.LevelDBDecoder, key_prefix: KeyPrefix,
-      base_offset: int = 0
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
+      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)
 
 
@@ -453,17 +486,19 @@ class MaxDatabaseIdKey(BaseIndexedDBKey):
 
   def DecodeValue(self, decoder: utils.LevelDBDecoder) -> int:
     """Decodes the maximum database value."""
-    return decoder.DecodeVarint()[1]
+    return decoder.DecodeInt()[1]
 
   @classmethod
   def FromDecoder(
-      cls, decoder: utils.LevelDBDecoder, key_prefix: KeyPrefix,
-      base_offset: int = 0
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
+      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)
 
 
@@ -473,17 +508,19 @@ class DataVersionKey(BaseIndexedDBKey):
 
   def DecodeValue(self, decoder: utils.LevelDBDecoder) -> int:
     """Decodes the data version value."""
-    return decoder.DecodeUint64Varint()[1]
+    return decoder.DecodeInt()[1]
 
   @classmethod
   def FromDecoder(
-      cls, decoder: utils.LevelDBDecoder, key_prefix: KeyPrefix,
-      base_offset: int = 0
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
+      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)
 
 
@@ -497,13 +534,15 @@ class RecoveryBlobJournalKey(BaseIndexedDBKey):
 
   @classmethod
   def FromDecoder(
-      cls, decoder: utils.LevelDBDecoder, key_prefix: KeyPrefix,
-      base_offset: int = 0
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
+      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)
 
 
@@ -517,13 +556,15 @@ class ActiveBlobJournalKey(BaseIndexedDBKey):
 
   @classmethod
   def FromDecoder(
-      cls, decoder: utils.LevelDBDecoder, key_prefix: KeyPrefix,
-      base_offset: int = 0
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
+      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)
 
 
@@ -534,17 +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
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
+      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)
 
 
@@ -555,17 +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
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
+      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)
 
 
@@ -575,19 +620,21 @@ 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
 
   @classmethod
   def FromDecoder(
-      cls, decoder: utils.LevelDBDecoder, key_prefix: KeyPrefix,
-      base_offset: int = 0
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
+      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)
 
 
@@ -598,25 +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
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
+      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
@@ -627,6 +679,7 @@ class DatabaseNameKey(BaseIndexedDBKey):
     origin: the origin of the database.
     database_name: the database name.
   """
+
   origin: str
   database_name: str
 
@@ -635,49 +688,47 @@ class DatabaseNameKey(BaseIndexedDBKey):
 
     The value is the corresponding database ID.
     """
-    return decoder.DecodeVarint()[1]
+    return decoder.DecodeInt()[1]
 
   @classmethod
   def FromDecoder(
-      cls, decoder: utils.LevelDBDecoder, key_prefix: KeyPrefix,
-      base_offset: int = 0
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
+      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
-          .SCHEMA_VERSION: SchemaVersionKey,
-      definitions.GlobalMetadataKeyType
-          .MAX_DATABASE_ID: MaxDatabaseIdKey,
-      definitions.GlobalMetadataKeyType
-          .DATA_VERSION: DataVersionKey,
-      definitions.GlobalMetadataKeyType
-          .RECOVERY_BLOB_JOURNAL: RecoveryBlobJournalKey,
-      definitions.GlobalMetadataKeyType
-          .ACTIVE_BLOB_JOURNAL: ActiveBlobJournalKey,
-      definitions.GlobalMetadataKeyType
-          .EARLIEST_SWEEP: EarliestSweepKey,
-      definitions.GlobalMetadataKeyType
-          .EARLIEST_COMPACTION_TIME: EarliestCompactionTimeKey,
-      definitions.GlobalMetadataKeyType
-          .SCOPES_PREFIX: ScopesPrefixKey,
-      definitions.GlobalMetadataKeyType
-          .DATABASE_FREE_LIST: DatabaseFreeListKey,
-      definitions.GlobalMetadataKeyType
-          .DATABASE_NAME: DatabaseNameKey}
+      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.
@@ -688,18 +739,22 @@ class GlobalMetaDataKey(BaseIndexedDBKey):
 
   @classmethod
   def FromDecoder(
-      cls, decoder: utils.LevelDBDecoder, key_prefix: KeyPrefix,
-      base_offset: int = 0
-  ) -> Union[Type[ActiveBlobJournalKey],
-             Type[DataVersionKey],
-             Type[DatabaseFreeListKey],
-             Type[DatabaseNameKey],
-             Type[EarliestSweepKey],
-             Type[EarliestCompactionTimeKey],
-             Type[MaxDatabaseIdKey],
-             Type[RecoveryBlobJournalKey],
-             Type[SchemaVersionKey],
-             Type[ScopesPrefixKey]]:
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
+      base_offset: int = 0,
+  ) -> Union[
+      ActiveBlobJournalKey,
+      DataVersionKey,
+      DatabaseFreeListKey,
+      DatabaseNameKey,
+      EarliestSweepKey,
+      EarliestCompactionTimeKey,
+      MaxDatabaseIdKey,
+      RecoveryBlobJournalKey,
+      SchemaVersionKey,
+      ScopesPrefixKey,
+  ]:
     """Decodes the global metadata key.
 
     Raises:
@@ -710,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)  #pytype: disable=bad-return-type
+      raise errors.ParserError("Unknown metadata key type")
+    return key_class.FromDecoder(  # type: ignore[attr-defined,no-any-return]
+        decoder, key_prefix, base_offset
+    )
 
 
 @dataclass
@@ -722,25 +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
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
+      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
@@ -750,25 +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:
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
+      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
@@ -778,22 +844,30 @@ class ObjectStoreNamesKey(BaseIndexedDBKey):
   Attributes:
     object_store_name: the name of the object store.
   """
+
   object_store_name: str
 
   def DecodeValue(self, decoder: utils.LevelDBDecoder) -> int:
     """Decodes the object store names value."""
-    return decoder.DecodeVarint()[1]
+    return decoder.DecodeInt()[1]
 
   @classmethod
-  def FromDecoder(cls, decoder: utils.LevelDBDecoder, key_prefix: KeyPrefix,
-                 base_offset: int = 0) -> ObjectStoreNamesKey:
+  def FromDecoder(
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
+      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
@@ -803,22 +877,30 @@ class IndexNamesKey(BaseIndexedDBKey):
   Attributes:
     index_name: the name of the index.
   """
+
   index_name: str
 
   def DecodeValue(self, decoder: utils.LevelDBDecoder) -> int:
     """Decodes the index names value."""
-    return decoder.DecodeVarint()[1]
+    return decoder.DecodeInt()[1]
 
   @classmethod
-  def FromDecoder(cls, decoder: utils.LevelDBDecoder, key_prefix: KeyPrefix,
-                 base_offset: int = 0) -> IndexNamesKey:
+  def FromDecoder(
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
+      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
@@ -828,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):
-      return decoder.DecodeVarint()[1]
-    if (self.metadata_type ==
-        definitions.DatabaseMetaDataKeyType.IDB_INTEGER_VERSION):
+    if (
+        self.metadata_type
+        == definitions.DatabaseMetaDataKeyType.MAX_ALLOCATED_OBJECT_STORE_ID
+    ):
+      return decoder.DecodeInt()[1]
+    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,
@@ -868,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])
@@ -879,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
@@ -915,68 +1008,91 @@ 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) -> Union[IDBKeyPath, str, bool, int]:
+      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
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
+      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:
   """The parsed values from an ObjectStoreDataKey.
 
   Attributes:
-    unknown: an unknown integer (possibly a sequence number?).
-    is_wrapped: True if the value was wrapped.
+    version: the version prefix.
     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.
   """
-  unknown: int
-  is_wrapped: bool
+
+  version: int
   blob_size: Optional[int]
   blob_offset: Optional[int]
   value: Any
@@ -989,51 +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."""
-    _, unknown_integer = decoder.DecodeVarint()
+    _, version = decoder.DecodeVarint()
 
     _, wrapped_header_bytes = decoder.PeekBytes(3)
     if len(wrapped_header_bytes) != 3:
-      raise errors.DecoderError('Insufficient bytes')
-
-    if (wrapped_header_bytes[0] == definitions.BlinkSerializationTag.VERSION and
-        wrapped_header_bytes[1] == 0x11 and
-        wrapped_header_bytes[2] == 0x01):
+      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
+    ):
+      _ = decoder.ReadBytes(3)
       _, blob_size = decoder.DecodeVarint()
       _, blob_offset = decoder.DecodeVarint()
       return ObjectStoreDataValue(
-          unknown=unknown_integer,
-          is_wrapped=True,
+          version=version,
           blob_size=blob_size,
           blob_offset=blob_offset,
-          value=None)
+          value=None,
+      )
+
     _, blink_bytes = decoder.ReadBytes()
     blink_value = blink.V8ScriptValueDecoder.FromBytes(blink_bytes)
     return ObjectStoreDataValue(
-        unknown=unknown_integer,
-        is_wrapped=False,
-        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
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
+      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
@@ -1043,25 +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
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
+      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
@@ -1073,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]
@@ -1084,8 +1213,12 @@ class IndexDataKey(BaseIndexedDBKey):
     return version, idb_key
 
   @classmethod
-  def FromDecoder(cls, decoder: utils.LevelDBDecoder, key_prefix: KeyPrefix,
-                 base_offset: int = 0) -> IndexDataKey:
+  def FromDecoder(
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
+      base_offset: int = 0,
+  ) -> IndexDataKey:
     """Decodes the index data key."""
     offset = decoder.stream.tell()
     encoded_user_key = IDBKey.FromDecoder(decoder, offset)
@@ -1098,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
 
@@ -1107,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
@@ -1117,24 +1252,29 @@ class BlobEntryKey(BaseIndexedDBKey):
   Attributes:
     user_key: the user/primary key.
   """
+
   user_key: IDBKey
 
   def DecodeValue(
-      self, decoder: utils.LevelDBDecoder) -> IndexedDBExternalObject:
+      self, decoder: utils.LevelDBDecoder
+  ) -> IndexedDBExternalObject:
     """Decodes the blob entry value."""
     return IndexedDBExternalObject.FromDecoder(decoder)
 
   @classmethod
   def FromDecoder(
-      cls, decoder: utils.LevelDBDecoder, key_prefix: KeyPrefix,
-      base_offset: int = 0
+      cls,
+      decoder: utils.LevelDBDecoder,
+      key_prefix: KeyPrefix,
+      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
@@ -1145,13 +1285,13 @@ class IndexedDbKey(BaseIndexedDBKey):
   """
 
   METADATA_TYPE_TO_CLASS = {
-      definitions.KeyPrefixType.GLOBAL_METADATA: GlobalMetaDataKey,
+      definitions.KeyPrefixType.BLOB_ENTRY: BlobEntryKey,
       definitions.KeyPrefixType.DATABASE_METADATA: DatabaseMetaDataKey,
-      definitions.KeyPrefixType.OBJECT_STORE_DATA: ObjectStoreDataKey,
       definitions.KeyPrefixType.EXISTS_ENTRY: ExistsEntryKey,
+      definitions.KeyPrefixType.GLOBAL_METADATA: GlobalMetaDataKey,
+      definitions.KeyPrefixType.INVALID_TYPE: None,
       definitions.KeyPrefixType.INDEX_DATA: IndexDataKey,
-      definitions.KeyPrefixType.BLOB_ENTRY: BlobEntryKey,
-      definitions.KeyPrefixType.INVALID_TYPE: None
+      definitions.KeyPrefixType.OBJECT_STORE_DATA: ObjectStoreDataKey,
   }
 
   def DecodeValue(self, decoder: utils.LevelDBDecoder) -> Any:
@@ -1166,19 +1306,25 @@ class IndexedDbKey(BaseIndexedDBKey):
       cls,
       decoder: utils.LevelDBDecoder,
       key_prefix: KeyPrefix,
-      base_offset: int = 0
-  ) -> Union[Type[DatabaseMetaDataKey], Type[ExistsEntryKey],
-             Type[BlobEntryKey], Type[GlobalMetaDataKey],
-             Type[IndexDataKey], Type[ObjectStoreDataKey]]:
+      base_offset: int = 0,
+  ) -> Union[
+      BlobEntryKey,
+      DatabaseMetaDataKey,
+      ExistsEntryKey,
+      GlobalMetaDataKey,
+      IndexDataKey,
+      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
@@ -1190,42 +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) -> Union[bool, IDBKeyPath, str]:
+      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
+      key_prefix: KeyPrefix,
+      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
@@ -1244,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]
@@ -1255,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()
@@ -1276,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
@@ -1287,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
@@ -1300,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 = []
@@ -1319,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.
@@ -1347,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
@@ -1356,72 +1511,97 @@ 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:
   """A IndexedDB folder reader for Chrome/Chromium.
 
   Attributes:
-    foldername (str): the source LevelDB folder.
+    folder_name (str): the source LevelDB folder.
   """
 
-  def __init__(self, foldername: pathlib.Path):
+  def __init__(self, folder_name: pathlib.Path):
     """Initializes the FileReader.
 
     Args:
-      foldername: the source IndexedDB folder.
+      folder_name: the source IndexedDB folder.
 
     Raises:
-      ValueError: if foldername is None or not a directory.
+      ValueError: if folder_name is None or not a directory.
     """
-    if not foldername or not foldername.is_dir():
-      raise ValueError(f'{foldername} is None or not a directory')
-    self.foldername = foldername
+    if not folder_name or not folder_name.is_dir():
+      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.
 
@@ -1429,23 +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.foldername)
+    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(
+            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)