libwz 0.1.0

package/include/wz/Properties/WzLuaProperty.h

@@ -0,0 +1,31 @@
+#ifndef WZ_PROPERTIES_WZLUAPROPERTY_H_
+#define WZ_PROPERTIES_WZLUAPROPERTY_H_
+#include <cstdint>
+#include <memory>
+#include <vector>
+#include "wz/Util/WzMutableKey.h"
+#include "wz/WzImageProperty.h"
+
+namespace wz {
+class WzLuaProperty : public WzImageProperty {
+ public:
+  WzLuaProperty(const std::string& name,
+                const std::vector<uint8_t>& encryptedBytes);
+  WZ_DISALLOW_COPY_AND_MOVE(WzLuaProperty)
+  WzPropertyType PropertyType() const override { return WzPropertyType::Lua; }
+  const std::vector<uint8_t>& Value() const { return encryptedBytes_; }
+  Result<void> WriteValue(WzBinaryWriter* writer) const override;
+  void SetValue(const std::vector<uint8_t>& value) override {
+    if (encryptedBytes_ == value) return;
+    encryptedBytes_ = value;
+    MarkParentImageChanged();
+  }
+  std::string GetString() const override;
+  std::vector<uint8_t> EncodeDecode(const std::vector<uint8_t>& input) const;
+
+ private:
+  std::vector<uint8_t> encryptedBytes_;
+  WzMutableKey wzKey_;
+};
+}  // namespace wz
+#endif  // WZ_PROPERTIES_WZLUAPROPERTY_H_

package/include/wz/Properties/WzNullProperty.h

@@ -0,0 +1,15 @@
+#ifndef WZ_PROPERTIES_WZNULLPROPERTY_H_
+#define WZ_PROPERTIES_WZNULLPROPERTY_H_
+#include "wz/WzImageProperty.h"
+
+namespace wz {
+class WzNullProperty : public WzImageProperty {
+ public:
+  WzNullProperty() = default;
+  explicit WzNullProperty(const std::string& name) { SetName(name); }
+  WZ_DISALLOW_COPY_AND_MOVE(WzNullProperty)
+  WzPropertyType PropertyType() const override { return WzPropertyType::Null; }
+  Result<void> WriteValue(WzBinaryWriter* writer) const override;
+};
+}  // namespace wz
+#endif  // WZ_PROPERTIES_WZNULLPROPERTY_H_

package/include/wz/Properties/WzPngProperty.h

@@ -0,0 +1,53 @@
+#ifndef WZ_PROPERTIES_WZPNGPROPERTY_H_
+#define WZ_PROPERTIES_WZPNGPROPERTY_H_
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <vector>
+#include "wz/Result.h"
+#include "wz/WzEnums.h"
+#include "wz/WzImageProperty.h"
+
+namespace wz {
+class WzBinaryReader;
+class WzPngProperty : public WzImageProperty {
+ public:
+  WzPngProperty();
+  WzPngProperty(WzBinaryReader* reader, bool parseNow);
+  WZ_DISALLOW_COPY_AND_MOVE(WzPngProperty)
+
+  static Result<std::unique_ptr<WzPngProperty>> FromPngFile(
+      const std::string& filePath);
+
+  WzPropertyType PropertyType() const override { return WzPropertyType::PNG; }
+  std::string Name() const override { return "PNG"; }
+  void SetName(const std::string&) override {}
+
+  int Width() const { return width_; }
+  int Height() const { return height_; }
+  WzPngFormat Format() const { return format_; }
+  bool ListWzUsed() const { return listWzUsed_; }
+
+  Result<std::vector<uint8_t>> GetImage(bool saveInMemory);
+  Result<std::vector<uint8_t>> GetCompressedBytes(bool saveInMemory);
+  Result<std::vector<uint8_t>> GetCompressedBytesForExtraction(
+      bool saveInMemory);
+  Result<std::vector<uint8_t>> GetRawImage(bool saveInMemory);
+  Result<void> ParsePng(bool saveInMemory);
+  Result<void> SaveToFile(const std::string& filePath);
+
+  WzBinaryReader* Reader() const { return wzReader_; }
+
+ private:
+  int width_ = 0, height_ = 0;
+  WzPngFormat format_ = WzPngFormat::Format1;
+  std::vector<uint8_t> compressedImageBytes_;
+  std::vector<uint8_t> pngData_;
+  bool listWzUsed_ = false;
+  WzBinaryReader* wzReader_ = nullptr;
+  int64_t offs_ = 0;
+
+  int GetUncompressedSize() const;
+};
+}  // namespace wz
+#endif  // WZ_PROPERTIES_WZPNGPROPERTY_H_

package/include/wz/Properties/WzRawDataProperty.h

@@ -0,0 +1,46 @@
+#ifndef WZ_PROPERTIES_WZRAWDATAPROPERTY_H_
+#define WZ_PROPERTIES_WZRAWDATAPROPERTY_H_
+#include <cstdint>
+#include <vector>
+#include "wz/Result.h"
+#include "wz/WzImageProperty.h"
+#include "wz/WzPropertyCollection.h"
+
+namespace wz {
+class WzBinaryReader;
+class WzRawDataProperty : public WzImageProperty, public IPropertyContainer {
+ public:
+  static constexpr const char* RAW_DATA_HEADER = "RawData";
+  WzRawDataProperty(const std::string& name,
+                    WzBinaryReader* reader,
+                    uint8_t type);
+  ~WzRawDataProperty() override;
+  WZ_DISALLOW_COPY_AND_MOVE(WzRawDataProperty)
+
+  WzPropertyType PropertyType() const override { return WzPropertyType::Raw; }
+  bool IsRawDataProperty() const override { return true; }
+  Result<void> WriteValue(WzBinaryWriter* writer) const override;
+  WzPropertyCollection* WzProperties() override { return &properties_; }
+  using IPropertyContainer::AddProperty;
+  Result<void> AddProperty(WzImageProperty* prop) override;
+  Result<void> AddProperty(std::unique_ptr<WzImageProperty> prop) override;
+  Result<std::unique_ptr<WzImageProperty>> RemoveProperty(
+      const std::string& propertyName) override;
+  Result<std::unique_ptr<WzImageProperty>> RemoveProperty(
+      WzImageProperty* prop) override;
+  Result<void> ClearProperties() override;
+  Result<std::vector<uint8_t>> GetBytes() override;
+  Result<std::vector<uint8_t>> GetBytes(bool saveInMemory);
+  void Parse(bool parseNow);
+  uint8_t Type() const { return type_; }
+
+ private:
+  WzBinaryReader* wzReader_ = nullptr;
+  uint8_t type_ = 0;
+  int64_t rawDataOffset_ = 0;
+  int length_ = 0;
+  std::vector<uint8_t> bytes_;
+  WzPropertyCollection properties_;
+};
+}  // namespace wz
+#endif  // WZ_PROPERTIES_WZRAWDATAPROPERTY_H_

package/include/wz/Properties/WzShortProperty.h

@@ -0,0 +1,31 @@
+#ifndef WZ_PROPERTIES_WZSHORTPROPERTY_H_
+#define WZ_PROPERTIES_WZSHORTPROPERTY_H_
+#include "wz/WzImageProperty.h"
+namespace wz {
+class WzShortProperty : public WzImageProperty {
+ public:
+  WzShortProperty() = default;
+  WzShortProperty(const std::string& name, int16_t value) : value_(value) {
+    SetName(name);
+  }
+  WZ_DISALLOW_COPY_AND_MOVE(WzShortProperty)
+  WzPropertyType PropertyType() const override { return WzPropertyType::Short; }
+  int16_t Value() const { return value_; }
+  Result<void> WriteValue(WzBinaryWriter* writer) const override;
+  void SetValue(int32_t value) override {
+    auto next = static_cast<int16_t>(value);
+    if (value_ == next) return;
+    value_ = next;
+    MarkParentImageChanged();
+  }
+  int32_t GetInt() const override { return value_; }
+  int16_t GetShort() const override { return value_; }
+  int64_t GetLong() const override { return value_; }
+  float GetFloat() const override { return static_cast<float>(value_); }
+  double GetDouble() const override { return static_cast<double>(value_); }
+
+ private:
+  int16_t value_ = 0;
+};
+}  // namespace wz
+#endif  // WZ_PROPERTIES_WZSHORTPROPERTY_H_

package/include/wz/Properties/WzStringProperty.h

@@ -0,0 +1,32 @@
+#ifndef WZ_PROPERTIES_WZSTRINGPROPERTY_H_
+#define WZ_PROPERTIES_WZSTRINGPROPERTY_H_
+#include "wz/WzImageProperty.h"
+namespace wz {
+class WzStringProperty : public WzImageProperty {
+ public:
+  WzStringProperty() = default;
+  WzStringProperty(const std::string& name, const std::string& value)
+      : value_(value) {
+    SetName(name);
+  }
+  WZ_DISALLOW_COPY_AND_MOVE(WzStringProperty)
+  WzPropertyType PropertyType() const override {
+    return WzPropertyType::String;
+  }
+  const std::string& Value() const { return value_; }
+  Result<void> WriteValue(WzBinaryWriter* writer) const override;
+  void SetValue(const std::string& value) override {
+    if (value_ == value) return;
+    value_ = value;
+    MarkParentImageChanged();
+  }
+  std::string GetString() const override { return value_; }
+  int32_t GetInt() const override;
+  int16_t GetShort() const override;
+  int64_t GetLong() const override;
+
+ private:
+  std::string value_;
+};
+}  // namespace wz
+#endif  // WZ_PROPERTIES_WZSTRINGPROPERTY_H_

package/include/wz/Properties/WzSubProperty.h

@@ -0,0 +1,35 @@
+#ifndef WZ_PROPERTIES_WZSUBPROPERTY_H_
+#define WZ_PROPERTIES_WZSUBPROPERTY_H_
+#include <string>
+#include "wz/WzImageProperty.h"
+#include "wz/WzPropertyCollection.h"
+
+namespace wz {
+class WzSubProperty : public WzImageProperty, public IPropertyContainer {
+ public:
+  WzSubProperty();
+  explicit WzSubProperty(const std::string& name);
+  ~WzSubProperty() override;
+  WZ_DISALLOW_COPY_AND_MOVE(WzSubProperty)
+
+  WzPropertyType PropertyType() const override {
+    return WzPropertyType::SubProperty;
+  }
+  Result<void> WriteValue(WzBinaryWriter* writer) const override;
+  WzPropertyCollection* WzProperties() override { return &properties_; }
+  using IPropertyContainer::AddProperty;
+  Result<void> AddProperty(WzImageProperty* prop) override;
+  Result<void> AddProperty(std::unique_ptr<WzImageProperty> prop) override;
+  Result<std::unique_ptr<WzImageProperty>> RemoveProperty(
+      const std::string& propertyName) override;
+  Result<std::unique_ptr<WzImageProperty>> RemoveProperty(
+      WzImageProperty* prop) override;
+  Result<void> ClearProperties() override;
+  WzImageProperty* operator[](const std::string& name) override;
+  WzImageProperty* GetFromPath(const std::string& path) override;
+
+ private:
+  WzPropertyCollection properties_;
+};
+}  // namespace wz
+#endif  // WZ_PROPERTIES_WZSUBPROPERTY_H_

package/include/wz/Properties/WzUOLProperty.h

@@ -0,0 +1,44 @@
+#ifndef WZ_PROPERTIES_WZUOLPROPERTY_H_
+#define WZ_PROPERTIES_WZUOLPROPERTY_H_
+#include <string>
+#include <vector>
+#include "wz/Result.h"
+#include "wz/WzImageProperty.h"
+
+namespace wz {
+class WzUOLProperty : public WzImageProperty {
+ public:
+  WzUOLProperty() = default;
+  WzUOLProperty(const std::string& name, const std::string& value);
+  WZ_DISALLOW_COPY_AND_MOVE(WzUOLProperty)
+  WzPropertyType PropertyType() const override { return WzPropertyType::UOL; }
+  const std::string& Value() const { return val_; }
+  Result<void> WriteValue(WzBinaryWriter* writer) const override;
+  void SetValue(const std::string& value) override {
+    if (val_ == value) return;
+    val_ = value;
+    linkVal_ = nullptr;
+    MarkParentImageChanged();
+  }
+
+  // All accessors delegate to the resolved LinkValue (matches C# UOLRES path)
+  WzPropertyCollection* WzProperties() override;
+  WzImageProperty* operator[](const std::string& name) override;
+  WzImageProperty* GetFromPath(const std::string& path) override;
+
+  int32_t GetInt() const override;
+  int16_t GetShort() const override;
+  int64_t GetLong() const override;
+  float GetFloat() const override;
+  double GetDouble() const override;
+  std::string GetString() const override;
+  Result<std::vector<uint8_t>> GetBytes() override;
+
+  WzObject* LinkValue() const;
+
+ private:
+  std::string val_;
+  mutable WzObject* linkVal_ = nullptr;
+};
+}  // namespace wz
+#endif  // WZ_PROPERTIES_WZUOLPROPERTY_H_

package/include/wz/Properties/WzVectorProperty.h

@@ -0,0 +1,40 @@
+#ifndef WZ_PROPERTIES_WZVECTORPROPERTY_H_
+#define WZ_PROPERTIES_WZVECTORPROPERTY_H_
+#include <memory>
+#include "wz/Properties/WzIntProperty.h"
+#include "wz/WzImageProperty.h"
+
+namespace wz {
+class WzVectorProperty : public WzImageProperty {
+ public:
+  WzVectorProperty() = default;
+  ~WzVectorProperty() override;
+  WZ_DISALLOW_COPY_AND_MOVE(WzVectorProperty)
+  explicit WzVectorProperty(const std::string& name) { SetName(name); }
+  WzVectorProperty(const std::string& name,
+                   std::unique_ptr<WzIntProperty> x,
+                   std::unique_ptr<WzIntProperty> y)
+      : X(std::move(x)), Y(std::move(y)) {
+    SetName(name);
+  }
+  WzVectorProperty(const std::string& name, int32_t x, int32_t y)
+      : X(std::make_unique<WzIntProperty>("", x)),
+        Y(std::make_unique<WzIntProperty>("", y)) {
+    SetName(name);
+  }
+  WzVectorProperty(const std::string& name, float x, float y)
+      : X(std::make_unique<WzIntProperty>("", static_cast<int32_t>(x))),
+        Y(std::make_unique<WzIntProperty>("", static_cast<int32_t>(y))) {
+    SetName(name);
+  }
+  WzPropertyType PropertyType() const override {
+    return WzPropertyType::Vector;
+  }
+  Result<void> WriteValue(WzBinaryWriter* writer) const override;
+  std::unique_ptr<WzIntProperty> X;
+  std::unique_ptr<WzIntProperty> Y;
+
+ private:
+};
+}  // namespace wz
+#endif  // WZ_PROPERTIES_WZVECTORPROPERTY_H_

package/include/wz/Properties/WzVideoProperty.h

@@ -0,0 +1,43 @@
+#ifndef WZ_PROPERTIES_WZVIDEOPROPERTY_H_
+#define WZ_PROPERTIES_WZVIDEOPROPERTY_H_
+#include <cstdint>
+#include <vector>
+#include "wz/Result.h"
+#include "wz/WzImageProperty.h"
+#include "wz/WzPropertyCollection.h"
+
+namespace wz {
+class WzBinaryReader;
+class WzVideoProperty : public WzImageProperty, public IPropertyContainer {
+ public:
+  static constexpr const char* CANVAS_VIDEO_HEADER = "Canvas#Video";
+  WzVideoProperty(const std::string& name, WzBinaryReader* reader);
+  ~WzVideoProperty() override;
+  WZ_DISALLOW_COPY_AND_MOVE(WzVideoProperty)
+
+  WzPropertyType PropertyType() const override { return WzPropertyType::Raw; }
+  bool IsVideoProperty() const override { return true; }
+  Result<void> WriteValue(WzBinaryWriter* writer) const override;
+  WzPropertyCollection* WzProperties() override { return &properties_; }
+  using IPropertyContainer::AddProperty;
+  Result<void> AddProperty(WzImageProperty* prop) override;
+  Result<void> AddProperty(std::unique_ptr<WzImageProperty> prop) override;
+  Result<std::unique_ptr<WzImageProperty>> RemoveProperty(
+      const std::string& propertyName) override;
+  Result<std::unique_ptr<WzImageProperty>> RemoveProperty(
+      WzImageProperty* prop) override;
+  Result<void> ClearProperties() override;
+  Result<std::vector<uint8_t>> GetBytes() override;
+  Result<std::vector<uint8_t>> GetBytes(bool saveInMemory);
+  void Parse(bool parseNow);
+
+ private:
+  WzBinaryReader* wzReader_ = nullptr;
+  int64_t offset_ = 0;
+  int length_ = 0;
+  int type_ = 0;
+  std::vector<uint8_t> bytes_;
+  WzPropertyCollection properties_;
+};
+}  // namespace wz
+#endif  // WZ_PROPERTIES_WZVIDEOPROPERTY_H_

package/include/wz/Result.h

@@ -0,0 +1,58 @@
+#ifndef WZ_RESULT_H_
+#define WZ_RESULT_H_
+#include <expected>
+#include <string>
+#include <utility>
+
+namespace wz {
+
+enum class ErrorCode {
+  Ok = 0,
+  NotImplemented,
+  InvalidArgument,
+  ParseError,
+  IoError,
+  DataError,
+  NotFound,
+};
+
+class Error {
+ public:
+  // NOLINTNEXTLINE(runtime/explicit)
+  Error(ErrorCode code, std::string message = {})
+      : code_(code), message_(std::move(message)) {}
+
+  ErrorCode code() const { return code_; }
+  const std::string& message() const { return message_; }
+
+  static Error NotImplemented(const std::string& msg = "Not implemented") {
+    return {ErrorCode::NotImplemented, msg};
+  }
+  static Error InvalidArgument(const std::string& msg) {
+    return {ErrorCode::InvalidArgument, msg};
+  }
+  static Error ParseError(const std::string& msg) {
+    return {ErrorCode::ParseError, msg};
+  }
+  static Error IoError(const std::string& msg) {
+    return {ErrorCode::IoError, msg};
+  }
+  static Error DataError(const std::string& msg) {
+    return {ErrorCode::DataError, msg};
+  }
+  static Error NotFound(const std::string& msg) {
+    return {ErrorCode::NotFound, msg};
+  }
+
+  explicit operator bool() const { return code_ == ErrorCode::Ok; }
+
+ private:
+  ErrorCode code_;
+  std::string message_;
+};
+
+template <typename T, typename E = Error>
+using Result = std::expected<T, E>;
+
+}  // namespace wz
+#endif  // WZ_RESULT_H_

package/include/wz/Util/Defines.h

@@ -0,0 +1,16 @@
+#ifndef WZ_UTIL_DEFINES_H_
+#define WZ_UTIL_DEFINES_H_
+
+#define WZ_DISALLOW_COPY(TypeName)                                             \
+  TypeName(const TypeName&) = delete;                                          \
+  TypeName& operator=(const TypeName&) = delete;
+
+#define WZ_DISALLOW_MOVE(TypeName)                                             \
+  TypeName(TypeName&&) = delete;                                               \
+  TypeName& operator=(TypeName&&) = delete;
+
+#define WZ_DISALLOW_COPY_AND_MOVE(TypeName)                                    \
+  WZ_DISALLOW_COPY(TypeName)                                                   \
+  WZ_DISALLOW_MOVE(TypeName)
+
+#endif  // WZ_UTIL_DEFINES_H_

package/include/wz/Util/ListFileParser.h

@@ -0,0 +1,20 @@
+#ifndef WZ_UTIL_LISTFILEPARSER_H_
+#define WZ_UTIL_LISTFILEPARSER_H_
+#include <array>
+#include <cstdint>
+#include <string>
+#include <vector>
+#include "wz/WzEnums.h"
+
+namespace wz {
+
+class ListFileParser {
+ public:
+  static std::vector<std::string> ParseListFile(const std::string& filePath,
+                                                WzMapleVersion version);
+  static std::vector<std::string> ParseListFile(
+      const std::string& filePath, const std::array<uint8_t, 4>& WzIv);
+};
+
+}  // namespace wz
+#endif  // WZ_UTIL_LISTFILEPARSER_H_

package/include/wz/Util/WzBinaryReader.h

@@ -0,0 +1,95 @@
+#ifndef WZ_UTIL_WZBINARYREADER_H_
+#define WZ_UTIL_WZBINARYREADER_H_
+#include <cstdint>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <vector>
+#include "wz/Result.h"
+#include "wz/Util/Defines.h"
+#include "wz/Util/WzDataSource.h"
+#include "wz/Util/WzKeyGenerator.h"
+#include "wz/Util/WzMutableKey.h"
+#include "wz/WzEnums.h"
+#include "wz/WzHeader.h"
+
+namespace wz {
+
+class WzBinaryReader {
+ public:
+  WzBinaryReader(std::shared_ptr<WzDataSource> source,
+                 const std::array<uint8_t, 4>& wzIv,
+                 int64_t startOffset = 0);
+  ~WzBinaryReader();
+  WZ_DISALLOW_COPY(WzBinaryReader)
+  WzBinaryReader(WzBinaryReader&& other) noexcept;
+  WzBinaryReader& operator=(WzBinaryReader&& other) noexcept;
+
+  WzMutableKey& GetWzKey() { return wzKey_; }
+  std::recursive_mutex& Mutex() const { return mutex_; }
+  uint32_t Hash() const { return hash_; }
+  void SetHash(uint32_t h) { hash_ = h; }
+  WzHeader* GetHeader() { return header_; }
+  void SetHeader(WzHeader* h) { header_ = h; }
+  int64_t StartOffset() const { return startOffset_; }
+
+  void SetOffsetFromFStartToPosition(int offset);
+  Result<void> RollbackStreamPosition(int byOffset);
+
+  std::string ReadString();
+  std::string ReadString(size_t length);
+  std::string ReadNullTerminatedString();
+  int32_t ReadCompressedInt();
+  int64_t ReadLong();
+  int64_t Available();
+  uint64_t SourceSize() const;
+  int64_t ReadOffset();
+
+  std::string ReadStringAtOffset(int64_t offset, bool readByte = false);
+  std::string DecryptString(const std::u16string& stringToDecrypt);
+  std::string DecryptNonUnicodeString(const std::u16string& stringToDecrypt);
+  std::string ReadStringBlock(int64_t offset);
+
+  // Base stream wrappers
+  uint8_t ReadByte();
+  int16_t ReadInt16();
+  int32_t ReadInt32();
+  int64_t ReadInt64();
+  uint16_t ReadUInt16();
+  uint32_t ReadUInt32();
+  uint64_t ReadUInt64();
+  float ReadSingle();
+  double ReadDouble();
+  std::vector<uint8_t> ReadBytes(size_t count);
+  int8_t ReadSByte();
+
+  int64_t Position();
+  void SetPosition(int64_t pos);
+  void PrintHexBytes(int numberOfBytes);
+  void Close();
+
+  // Note: WzKey must be accessed via GetWzKey() which returns non-const
+  // reference
+
+ private:
+  static constexpr size_t kCacheSize = 256 * 1024;
+
+  std::shared_ptr<WzDataSource> source_;
+  int64_t position_ = 0;
+  std::vector<uint8_t> cache_;
+  uint64_t cacheOffset_ = 0;
+  size_t cacheSize_ = 0;
+  WzMutableKey wzKey_;
+  uint32_t hash_ = 0;
+  WzHeader* header_ = nullptr;
+  int64_t startOffset_ = 0;
+  mutable std::recursive_mutex mutex_;
+
+  std::string DecodeUnicode(int length);
+  std::string DecodeAscii(int length);
+  bool ReadExact(void* destination, size_t count);
+  bool FillCache();
+};
+
+}  // namespace wz
+#endif  // WZ_UTIL_WZBINARYREADER_H_

package/include/wz/Util/WzBinaryWriter.h

@@ -0,0 +1,72 @@
+#ifndef WZ_UTIL_WZBINARYWRITER_H_
+#define WZ_UTIL_WZBINARYWRITER_H_
+#include <array>
+#include <cstdint>
+#include <string>
+#include <unordered_map>
+#include "wz/Util/Defines.h"
+#include "wz/Util/WzKeyGenerator.h"
+#include "wz/Util/WzMutableKey.h"
+#include "wz/Util/WzStream.h"
+#include "wz/WzEnums.h"
+#include "wz/WzHeader.h"
+
+namespace wz {
+
+class WzBinaryWriter {
+ public:
+  WzBinaryWriter(WzStream& output, const std::array<uint8_t, 4>& WzIv);
+  WzBinaryWriter(WzStream& output,
+                 const std::array<uint8_t, 4>& WzIv,
+                 uint32_t hash);
+  ~WzBinaryWriter() = default;
+  WZ_DISALLOW_COPY(WzBinaryWriter)
+  WzBinaryWriter(WzBinaryWriter&& other) noexcept;
+  WzBinaryWriter& operator=(WzBinaryWriter&& other) noexcept;
+
+  WzMutableKey& GetWzKey() { return wzKey_; }
+  uint32_t Hash() const { return hash_; }
+  void SetHash(uint32_t h) { hash_ = h; }
+  WzHeader* GetHeader() { return &header_; }
+  void SetHeader(const WzHeader& h) { header_ = h; }
+  WzStream& BaseStream() { return *output_; }
+  void ClearStringCache();
+
+  int64_t Position();
+
+  void WriteByte(uint8_t value);
+  void WriteSByte(int8_t value);
+  void WriteInt16(int16_t value);
+  void WriteInt32(int32_t value);
+  void WriteInt64(int64_t value);
+  void WriteUInt16(uint16_t value);
+  void WriteUInt32(uint32_t value);
+  void WriteUInt64(uint64_t value);
+  void WriteSingle(float value);
+  void WriteDouble(double value);
+  void WriteString(const std::string& value);
+  void WriteNullTerminatedString(const std::string& value);
+  void WriteStringValue(const std::string& value,
+                        uint8_t withoutOffset,
+                        uint8_t withOffset);
+  bool WriteWzObjectValue(const std::string& value, WzDirectoryType type);
+  void WriteCompressedInt(int32_t value);
+  void WriteCompressedLong(int64_t value);
+  void WriteOffset(int64_t value);
+
+ private:
+  WzStream* output_ = nullptr;
+  WzMutableKey wzKey_;
+  uint32_t hash_ = 0;
+  WzHeader header_ = WzHeader::GetDefault();
+  std::unordered_map<std::string, int32_t> stringCache_;
+
+  template <typename T>
+  void WriteLittleEndian(T value);
+  bool WriteRawByte(uint8_t value);
+  void WriteAsciiString(const std::string& value);
+  void WriteUnicodeString(const std::u16string& value);
+};
+
+}  // namespace wz
+#endif  // WZ_UTIL_WZBINARYWRITER_H_

package/include/wz/Util/WzBlobDataSource.h

@@ -0,0 +1,30 @@
+#ifndef WZ_UTIL_WZBLOBDATASOURCE_H_
+#define WZ_UTIL_WZBLOBDATASOURCE_H_
+
+#include <cstdint>
+#include <functional>
+#include <span>
+
+#include "wz/Util/WzDataSource.h"
+
+namespace wz {
+
+class WzBlobDataSource final : public WzDataSource {
+ public:
+  using ReadCallback =
+      std::function<Result<size_t>(uint64_t, std::span<uint8_t>)>;
+
+  WzBlobDataSource(uint64_t size, ReadCallback read_callback);
+
+  Result<size_t> ReadAt(uint64_t offset,
+                        std::span<uint8_t> destination) override;
+  uint64_t Size() const override;
+
+ private:
+  uint64_t size_;
+  ReadCallback read_callback_;
+};
+
+}  // namespace wz
+
+#endif  // WZ_UTIL_WZBLOBDATASOURCE_H_