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

dfindexeddb/indexeddb/chromium/record.py

@@ -15,28 +15,32 @@
 """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,
+    ClassVar,
+    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", bound="BaseIndexedDBKey")
 
 
-@dataclass
+@dataclass(frozen=True)
 class KeyPrefix(utils.FromDecoderMixin):
   """The IndexedDB key prefix.
 
@@ -46,6 +50,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 +58,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.
 
@@ -72,28 +75,27 @@ class KeyPrefix(utils.FromDecoderMixin):
     """
     offset, raw_prefix = decoder.ReadBytes(1)
 
-    database_id_length = (raw_prefix[0] & 0xE0 >> 5) + 1
-    object_store_id_length = (raw_prefix[0] & 0x1C >> 2) + 1
+    database_id_length = ((raw_prefix[0] & 0xE0) >> 5) + 1
+    object_store_id_length = ((raw_prefix[0] & 0x1C) >> 2) + 1
     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')
-
-    _, database_id = decoder.DecodeInt(database_id_length)
-    _, object_store_id = decoder.DecodeInt(object_store_id_length)
-    _, index_id = decoder.DecodeInt(index_id_length)
+      raise errors.ParserError("Invalid 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 +118,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 +131,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 +142,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 +159,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 +181,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,19 +203,108 @@ 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)
     return cls(base_offset + offset, key_type, value)
 
 
+@dataclass(frozen=True)
+class SortableIDBKey(utils.FromDecoderMixin):
+  """A sortable IDBKey.
+
+  Attributes:
+    offset: the offset of the IDBKey.
+    type: the type of the IDBKey.
+    value: the value of the IDBKey.
+  """
+
+  offset: int = field(compare=False)
+  type: definitions.IDBKeyType
+  value: Union[list[Any], bytes, str, float, datetime, None]
+
+  _MAXIMUM_DEPTH = 2000
+
+  @classmethod
+  def FromDecoder(
+      cls,
+      decoder: utils.LevelDBDecoder,
+      base_offset: int = 0,
+  ) -> SortableIDBKey:
+    """Decodes a sortable IDBKey from the current position of a LevelDBDecoder.
+
+    Args:
+      decoder: the LevelDBDecoder.
+      base_offset: the base offset.
+
+    Returns:
+      The decoded SortableIDBKey.
+
+    Raises:
+      ParserError: on invalid key type or truncated data.
+      RecursionError: if maximum depth encountered.
+    """
+
+    def RecursiveParse(depth: int) -> Tuple[int, definitions.IDBKeyType, Any]:
+      """Recursively parses sortable IDBKeys.
+
+      Args:
+        depth: the current recursion depth.
+
+      Returns:
+        A tuple of the offset, the key type and the key value (where the value
+          can be bytes, str, float, datetime or a list of these types).
+
+      Raises:
+        ParserError: on invalid IDBKeyType or invalid array length during
+          parsing.
+        RecursionError: if maximum depth encountered during parsing.
+      """
+      if depth == cls._MAXIMUM_DEPTH:
+        raise RecursionError("Maximum recursion depth encountered")
+
+      value: Any = None
+      offset, ordered_type = decoder.DecodeUint8()
+      if ordered_type == definitions.OrderedIDBKeyType.NUMBER:
+        _, value = decoder.DecodeSortableDouble()
+        return offset, definitions.IDBKeyType.NUMBER, value
+      if ordered_type == definitions.OrderedIDBKeyType.DATE:
+        _, raw_date = decoder.DecodeSortableDouble()
+        return (
+            offset,
+            definitions.IDBKeyType.DATE,
+            datetime.utcfromtimestamp(raw_date / 1000.0),
+        )
+      if ordered_type == definitions.OrderedIDBKeyType.STRING:
+        _, value = decoder.DecodeSortableString()
+        return offset, definitions.IDBKeyType.STRING, value
+      if ordered_type == definitions.OrderedIDBKeyType.BINARY:
+        _, value = decoder.DecodeSortableBinary()
+        return offset, definitions.IDBKeyType.BINARY, value
+      if ordered_type == definitions.OrderedIDBKeyType.ARRAY:
+        value = []
+        while True:
+          _, next_byte = decoder.PeekBytes(1)
+          if next_byte[0] == definitions.SENTINEL:
+            decoder.ReadBytes(1)
+            break
+          _, _, item = RecursiveParse(depth + 1)
+          value.append(item)
+        return offset, definitions.IDBKeyType.ARRAY, value
+
+      raise errors.ParserError(f"Unknown ordered key type {ordered_type}")
+
+    offset, key_type, value = RecursiveParse(0)
+    return cls(base_offset + offset, key_type, value)
+
+
 @dataclass
 class IDBKeyPath(utils.FromDecoderMixin):
   """An IDBKeyPath.
@@ -217,15 +314,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 +336,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.")
+
+    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)
 
@@ -261,12 +359,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 +377,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 +397,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 +412,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 +459,7 @@ class BaseIndexedDBKey:
     offset: the offset of the key (after the key_prefix).
     key_prefix: the key prefix.
   """
+
   offset: int
   key_prefix: KeyPrefix
 
@@ -371,16 +471,19 @@ class BaseIndexedDBKey:
     Args:
       decoder: the stream decoder
 
+    Returns:
+      The decoded value.
+
     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.
 
     Args:
-      value_data: the raw value bytes.
+      value_data: the raw value data.
 
     Returns:
       The parsed value.
@@ -392,17 +495,19 @@ 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
-    """Decodes the remaining key data from the current decoder position.
+      base_offset: int = 0,
+  ) -> T:
+    """Parses the key from the current position of the LevelDBDecoder.
+
+    To be implemented by subclasses.
 
     Args:
       decoder: the stream decoder.
-      key_prefix: the decoded key_prefix.
-      base_offset: the base offset.
+      key_prefix: the key prefix.
+      base_offset: the base offset of the key.
 
     Returns:
       The decoded key.
@@ -410,7 +515,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:
@@ -426,7 +531,8 @@ 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)
+        decoder=decoder, key_prefix=key_prefix, base_offset=base_offset
+    )
 
   @classmethod
   def FromBytes(cls: Type[T], raw_data: bytes, base_offset: int = 0) -> T:
@@ -456,12 +562,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 +584,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 +606,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 +628,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 +650,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 +666,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 +689,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 +711,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 +720,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 +736,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 +770,7 @@ class DatabaseNameKey(BaseIndexedDBKey):
     origin: the origin of the database.
     database_name: the database name.
   """
+
   origin: str
   database_name: str
 
@@ -676,45 +786,44 @@ 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."""
 
-  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,
+  # pylint: disable=line-too-long
+  METADATA_TYPE_TO_CLASS: ClassVar[
+      dict[  # pylint: disable=invalid-name
+          definitions.GlobalMetadataKeyType, type[BaseIndexedDBKey]
+      ]
+  ] = {
+      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 +837,8 @@ 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,
+  ) -> BaseIndexedDBKey:
     """Decodes the global metadata key.
 
     Raises:
@@ -749,9 +849,8 @@ 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(decoder, key_prefix, base_offset)
 
 
 @dataclass
@@ -761,27 +860,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 +893,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 +926,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 +935,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 +959,7 @@ class IndexNamesKey(BaseIndexedDBKey):
   Attributes:
     index_name: the name of the index.
   """
+
   index_name: str
 
   def DecodeValue(self, decoder: utils.LevelDBDecoder) -> int:
@@ -860,15 +971,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 +992,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 +1038,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 +1050,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 +1090,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 +1169,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 +1187,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 +1249,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 +1283,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 +1299,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 +1313,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 +1323,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 +1334,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 +1348,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
@@ -1224,7 +1366,11 @@ class IndexedDbKey(BaseIndexedDBKey):
   A factory class for parsing IndexedDB keys.
   """
 
-  METADATA_TYPE_TO_CLASS = {
+  METADATA_TYPE_TO_CLASS: ClassVar[
+      dict[  # pylint: disable=invalid-name
+          definitions.KeyPrefixType, Optional[type[BaseIndexedDBKey]]
+      ]
+  ] = {
       definitions.KeyPrefixType.BLOB_ENTRY: BlobEntryKey,
       definitions.KeyPrefixType.DATABASE_METADATA: DatabaseMetaDataKey,
       definitions.KeyPrefixType.EXISTS_ENTRY: ExistsEntryKey,
@@ -1246,23 +1392,18 @@ class IndexedDbKey(BaseIndexedDBKey):
       cls,
       decoder: utils.LevelDBDecoder,
       key_prefix: KeyPrefix,
-      base_offset: int = 0
-  ) -> Union[
-      BlobEntryKey,
-      DatabaseMetaDataKey,
-      ExistsEntryKey,
-      GlobalMetaDataKey,
-      IndexDataKey,
-      ObjectStoreDataKey]:
+      base_offset: int = 0,
+  ) -> BaseIndexedDBKey:
     """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,
+        base_offset=base_offset,
+    )
 
 
 @dataclass
@@ -1274,45 +1415,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 +1476,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 +1488,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 +1508,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 +1521,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 +1541,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 = []
@@ -1407,22 +1560,8 @@ class IndexedDBExternalObject(utils.FromDecoderMixin):
 
 
 @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.
+class ChromiumIndexedDBRecord:
+  """An IndexedDB Record parsed from LevelDB.
 
   Attributes:
     path: the source file path
@@ -1434,7 +1573,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.
+    blobs: the list of blob paths and contents or error message, if available.
+    raw_key: the raw key, if available.
+    raw_value: the raw value, if available.
   """
+
   path: str
   offset: int
   key: Any
@@ -1443,46 +1590,181 @@ 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
+  blobs: Optional[list[tuple[str, Optional[Any]]]] = None
+  raw_key: Optional[bytes] = None
+  raw_value: Optional[bytes] = None
 
   @classmethod
   def FromLevelDBRecord(
       cls,
-      db_record: record.LevelDBRecord
-  ) -> IndexedDBRecord:
-    """Returns an IndexedDBRecord from a ParsedInternalKey."""
+      db_record: record.LevelDBRecord,
+      parse_value: bool = True,
+      include_raw_data: bool = False,
+      blob_folder_reader: Optional[BlobFolderReader] = None,
+  ) -> ChromiumIndexedDBRecord:
+    """Returns an ChromiumIndexedDBRecord 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
+
+    blobs = []
+    if isinstance(idb_value, IndexedDBExternalObject) and blob_folder_reader:
+      for (
+          blob_path_or_error,
+          blob_data,
+      ) in blob_folder_reader.ReadBlobsFromExternalObjectEntries(
+          idb_key.key_prefix.database_id, idb_value.entries
+      ):
+        if blob_data:
+          blob = blink.V8ScriptValueDecoder.FromBytes(blob_data)
+        else:
+          blob = None
+        blobs.append((blob_path_or_error, blob))
+
     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,
+        blobs=blobs,
+        raw_key=db_record.record.key if include_raw_data else None,
+        raw_value=db_record.record.value if include_raw_data else None,
+    )
 
   @classmethod
   def FromFile(
       cls,
-      file_path: pathlib.Path
-  ) -> Generator[IndexedDBRecord, None, None]:
-    """Yields IndexedDBRecords from a file."""
+      file_path: pathlib.Path,
+      parse_value: bool = True,
+      include_raw_data: bool = False,
+      blob_folder_reader: Optional[BlobFolderReader] = None,
+  ) -> Generator[ChromiumIndexedDBRecord, None, None]:
+    """Yields ChromiumIndexedDBRecord 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,
+            include_raw_data=include_raw_data,
+            blob_folder_reader=blob_folder_reader,
+        )
+      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 BlobFolderReader:
+  """A blob folder reader for Chrome/Chromium.
+
+  Attributes:
+    folder_name (str): the source blob folder.
+  """
+
+  def __init__(self, folder_name: pathlib.Path):
+    """Initializes the BlobFolderReader.
+
+    Args:
+      folder_name: the source blob folder.
+
+    Raises:
+      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")
+    self.folder_name = folder_name.absolute()
+
+  def ReadBlob(self, database_id: int, blob_id: int) -> tuple[str, bytes]:
+    """Reads a blob from the blob folder.
+
+    Args:
+      database_id: the database id of the blob to read.
+      blob_id: the blob id to read.
+
+    Returns:
+      A tuple of the blob path and contents.
+
+    Raises:
+      FileNotFoundError: if the database directory or blob folder or blob not
+          found.
+    """
+    directory_path = self.folder_name / f"{database_id:x}"
+    if not directory_path.exists():
+      raise FileNotFoundError(f"Database directory not found: {directory_path}")
+
+    blob_folder = directory_path / f"{(blob_id & 0xff00) >> 8:02x}"
+    if not blob_folder.exists():
+      raise FileNotFoundError(f"Blob folder not found: {blob_folder}")
+
+    blob_path = blob_folder / f"{blob_id:x}"
+    if not blob_path.exists():
+      raise FileNotFoundError(f"Blob ({blob_id}) not found: {blob_path}")
+
+    with open(blob_path, "rb") as f:
+      return str(blob_path), f.read()
+
+  def ReadBlobsFromExternalObjectEntries(
+      self, database_id: int, entries: list[ExternalObjectEntry]
+  ) -> Generator[tuple[str, Optional[bytes]], None, None]:
+    """Reads blobs from the blob folder.
+
+    Args:
+      database_id: the database id.
+      entries: the external object entries.
+
+    Yields:
+      A tuple of blob path and contents or if the blob is not found, an error
+      message and None.
+    """
+    for entry in entries:
+      if (
+          entry.object_type
+          in (
+              definitions.ExternalObjectType.BLOB,
+              definitions.ExternalObjectType.FILE,
+          )
+          and entry.blob_number is not None
+      ):
+        try:
+          yield self.ReadBlob(database_id, entry.blob_number)
+        except FileNotFoundError as err:
+          error_message = (
+              f"Blob not found for ExternalObjectEntry at offset {entry.offset}"
+              f": {err}"
+          )
+          print(error_message, file=sys.stderr)
+          yield error_message, None
 
 
 class FolderReader:
@@ -1502,36 +1784,59 @@ 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')
-    self.folder_name = folder_name
+      raise ValueError(f"{folder_name} is None or not a directory")
+    self.folder_name = folder_name.absolute()
+
+    # Locate the correponding blob folder. The folder_name should be
+    # <origin>.leveldb and the blob folder should be <origin>.blob
+    if str(self.folder_name).endswith(".leveldb"):
+      self.blob_folder_reader = BlobFolderReader(
+          pathlib.Path(str(self.folder_name).replace(".leveldb", ".blob"))
+      )
+    else:
+      self.blob_folder_reader = None  # type: ignore[assignment]
 
   def GetRecords(
       self,
       use_manifest: bool = False,
-      use_sequence_number: bool = False
-  ) -> Generator[IndexedDBRecord, None, None]:
-    """Yield LevelDBRecords.
+      use_sequence_number: bool = False,
+      parse_value: bool = True,
+      include_raw_data: bool = False,
+  ) -> Generator[ChromiumIndexedDBRecord, None, None]:
+    """Yields ChromiumIndexedDBRecord.
 
     Args:
       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.
+      ChromiumIndexedDBRecord.
     """
     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 ChromiumIndexedDBRecord.FromLevelDBRecord(
+            leveldb_record,
+            parse_value=parse_value,
+            include_raw_data=include_raw_data,
+            blob_folder_reader=self.blob_folder_reader,
+        )
+      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)