Fluorine Manager: full Linux port of Mod Organizer 2

Complete native Linux port with FUSE-based virtual filesystem,
Proton/umu-run integration, and Flatpak packaging.

Key features:
- FUSE VFS replacing Windows USVFS (in-process + standalone helper for Flatpak)
- Proton/GE-Proton/umu-run launcher with env var forwarding
- Flatpak support (sandbox-aware VFS, NXM handler, umu-run)
- Wine prefix management UI
- Case-insensitive path resolution for Linux filesystems
- QSettings-safe INI handling (avoids Bethesda INI corruption)
- Portable instance support with auto-generated launcher scripts

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

9 files changed, 1213 insertions, 0 deletions

diff --git a/libs/archive/thirdparty/CPP/Common/Common.h b/libs/archive/thirdparty/CPP/Common/Common.h
new file mode 100644
index 0000000..cde0c38
--- /dev/null
+++ b/libs/archive/thirdparty/CPP/Common/Common.h
@@ -0,0 +1,28 @@
+// Common.h
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+
+#ifndef ZIP7_INC_COMMON_H
+#define ZIP7_INC_COMMON_H
+
+#include "../../C/Precomp.h"
+#include "Common0.h"
+#include "MyWindows.h"
+
+/*
+This file is included to all cpp files in 7-Zip.
+Each folder contains StdAfx.h file that includes "Common.h".
+So 7-Zip includes "Common.h" in both modes:
+  with precompiled StdAfx.h
+and
+  without precompiled StdAfx.h
+
+include "Common.h" before other h files of 7-zip,
+   if you need predefined macros.
+do not include "Common.h", if you need only interfaces,
+   and you don't need predefined macros.
+*/
+
+#endif
diff --git a/libs/archive/thirdparty/CPP/Common/Common0.h b/libs/archive/thirdparty/CPP/Common/Common0.h
new file mode 100644
index 0000000..55606cd
--- /dev/null
+++ b/libs/archive/thirdparty/CPP/Common/Common0.h
@@ -0,0 +1,330 @@
+// Common0.h
+
+#if defined(_MSC_VER) && _MSC_VER >= 1800
+#pragma warning(disable : 4464) // relative include path contains '..'
+#endif
+
+#ifndef ZIP7_INC_COMMON0_H
+#define ZIP7_INC_COMMON0_H
+
+#include "../../C/Compiler.h"
+
+/*
+This file contains compiler related things for cpp files.
+This file is included to all cpp files in 7-Zip via "Common.h".
+Also this file is included in "IDecl.h" (that is included in interface files).
+So external modules can use 7-Zip interfaces without
+predefined macros defined in "Common.h".
+*/
+
+#ifdef _MSC_VER
+  #pragma warning(disable : 4710) // function not inlined
+  // 'CUncopyable::CUncopyable':
+  #pragma warning(disable : 4514) // unreferenced inline function has been removed
+  #if _MSC_VER < 1300
+    #pragma warning(disable : 4702) // unreachable code
+    #pragma warning(disable : 4714) // function marked as __forceinline not inlined
+    #pragma warning(disable : 4786) // identifier was truncated to '255' characters in the debug information
+  #endif
+  #if _MSC_VER < 1400
+    #pragma warning(disable : 4511) // copy constructor could not be generated    // #pragma warning(disable : 4512) // assignment operator could not be generated
+    #pragma warning(disable : 4512) // assignment operator could not be generated
+  #endif
+  #if _MSC_VER > 1400 && _MSC_VER <= 1900
+    // #pragma warning(disable : 4996)
+       // strcat: This function or variable may be unsafe
+       // GetVersion was declared deprecated
+  #endif
+
+#if _MSC_VER > 1200
+// -Wall warnings
+
+#if _MSC_VER <= 1600
+#pragma warning(disable : 4917) // 'OLE_HANDLE' : a GUID can only be associated with a class, interface or namespace
+#endif
+
+// #pragma warning(disable : 4061) // enumerator '' in switch of enum '' is not explicitly handled by a case label
+// #pragma warning(disable : 4266) // no override available for virtual member function from base ''; function is hidden
+#pragma warning(disable : 4625) // copy constructor was implicitly defined as deleted
+#pragma warning(disable : 4626) // assignment operator was implicitly defined as deleted
+#if _MSC_VER >= 1600 && _MSC_VER < 1920
+#pragma warning(disable : 4571) // Informational: catch(...) semantics changed since Visual C++ 7.1; structured exceptions (SEH) are no longer caught
+#endif
+#if _MSC_VER >= 1600
+#pragma warning(disable : 4365) // 'initializing' : conversion from 'int' to 'unsigned int', signed / unsigned mismatch
+#endif
+#if _MSC_VER < 1800
+// we disable the warning, if we don't use 'final' in class
+#pragma warning(disable : 4265) // class has virtual functions, but destructor is not virtual
+#endif
+
+#if _MSC_VER >= 1900
+#pragma warning(disable : 5026) // move constructor was implicitly defined as deleted
+#pragma warning(disable : 5027) // move assignment operator was implicitly defined as deleted
+#endif
+#if _MSC_VER >= 1912
+#pragma warning(disable : 5039) // pointer or reference to potentially throwing function passed to 'extern "C"' function under - EHc.Undefined behavior may occur if this function throws an exception.
+#endif
+#if _MSC_VER >= 1925
+// #pragma warning(disable : 5204) // 'ISequentialInStream' : class has virtual functions, but its trivial destructor is not virtual; instances of objects derived from this class may not be destructed correctly
+#endif
+#if _MSC_VER >= 1934
+// #pragma warning(disable : 5264) // const variable is not used
+#endif
+
+#endif // _MSC_VER > 1200
+#endif // _MSC_VER
+
+
+#if defined(_MSC_VER) // && !defined(__clang__)
+#define Z7_DECLSPEC_NOTHROW   __declspec(nothrow)
+#elif defined(__clang__) || defined(__GNUC__)
+#define Z7_DECLSPEC_NOTHROW   __attribute__((nothrow))
+#else
+#define Z7_DECLSPEC_NOTHROW
+#endif
+
+/*
+#if defined (_MSC_VER) && _MSC_VER >= 1900 \
+    || defined(__clang__) && __clang_major__ >= 6 \
+    || defined(__GNUC__) && __GNUC__ >= 6
+  #define Z7_noexcept noexcept
+#else
+  #define Z7_noexcept throw()
+#endif
+*/
+
+
+#if defined(__clang__)
+
+#if /* defined(_WIN32) && */ __clang_major__ >= 16
+#pragma GCC diagnostic ignored "-Wc++98-compat-pedantic"
+#endif
+
+#if __clang_major__ >= 4 && __clang_major__ < 12 && !defined(_WIN32)
+/*
+if compiled with new GCC libstdc++, GCC libstdc++ can use:
+13.2.0/include/c++/
+    <new> : #define _NEW
+    <stdlib.h> : #define _GLIBCXX_STDLIB_H 1
+*/
+#pragma GCC diagnostic ignored "-Wreserved-id-macro"
+#endif
+
+// noexcept, final, = delete
+#pragma GCC diagnostic ignored "-Wc++98-compat"
+#if __clang_major__ >= 4
+// throw() dynamic exception specifications are deprecated
+#pragma GCC diagnostic ignored "-Wdeprecated-dynamic-exception-spec"
+#endif
+
+#if __clang_major__ <= 6 // check it
+#pragma GCC diagnostic ignored "-Wsign-conversion"
+#endif
+
+#pragma GCC diagnostic ignored "-Wold-style-cast"
+#pragma GCC diagnostic ignored "-Wglobal-constructors"
+#pragma GCC diagnostic ignored "-Wexit-time-destructors"
+
+#if defined(Z7_LLVM_CLANG_VERSION) && __clang_major__ >= 18 // 18.1.0RC
+#pragma GCC diagnostic ignored "-Wswitch-default"
+#endif
+// #pragma GCC diagnostic ignored "-Wunused-private-field"
+// #pragma GCC diagnostic ignored "-Wnonportable-system-include-path"
+// #pragma GCC diagnostic ignored "-Wsuggest-override"
+// #pragma GCC diagnostic ignored "-Wsign-conversion"
+// #pragma GCC diagnostic ignored "-Winconsistent-missing-override"
+// #pragma GCC diagnostic ignored "-Wsuggest-destructor-override"
+// #pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
+// #pragma GCC diagnostic ignored "-Wdeprecated-copy-with-user-provided-dtor"
+// #pragma GCC diagnostic ignored "-Wdeprecated-copy-dtor"
+// #ifndef _WIN32
+// #pragma GCC diagnostic ignored "-Wweak-vtables"
+// #endif
+/*
+#if   defined(Z7_GCC_VERSION)   && (Z7_GCC_VERSION   >= 40400) \
+   || defined(Z7_CLANG_VERSION) && (Z7_CLANG_VERSION >= 30000)
+// enumeration values not explicitly handled in switch
+#pragma GCC diagnostic ignored "-Wswitch-enum"
+#endif
+*/
+#endif // __clang__
+
+
+#ifdef __GNUC__
+// #pragma GCC diagnostic ignored "-Wdelete-non-virtual-dtor"
+#endif
+
+
+/* There is BUG in MSVC 6.0 compiler for operator new[]:
+   It doesn't check overflow, when it calculates size in bytes for allocated array.
+   So we can use Z7_ARRAY_NEW macro instead of new[] operator. */
+
+#if defined(_MSC_VER) && (_MSC_VER == 1200) && !defined(_WIN64)
+  #define Z7_ARRAY_NEW(p, T, size)  p = new T[((size) > 0xFFFFFFFFu / sizeof(T)) ? 0xFFFFFFFFu / sizeof(T) : (size)];
+#else
+  #define Z7_ARRAY_NEW(p, T, size)  p = new T[size];
+#endif
+
+#if (defined(__GNUC__) && (__GNUC__ >= 8))
+  #define Z7_ATTR_NORETURN  __attribute__((noreturn))
+#elif (defined(__clang__) && (__clang_major__ >= 3))
+  #if __has_feature(cxx_attributes)
+    #define Z7_ATTR_NORETURN  [[noreturn]]
+  #else
+    #define Z7_ATTR_NORETURN  __attribute__((noreturn))
+  #endif
+#elif (defined(_MSC_VER) && (_MSC_VER >= 1900))
+  #define Z7_ATTR_NORETURN  [[noreturn]]
+#else
+  #define Z7_ATTR_NORETURN
+#endif
+
+
+// final in "GCC 4.7.0"
+// In C++98 and C++03 code the alternative spelling __final can be used instead (this is a GCC extension.)
+
+#if defined (__cplusplus) && __cplusplus >= 201103L \
+    || defined(_MSC_VER) && _MSC_VER >= 1800 \
+    || defined(__clang__) && __clang_major__ >= 4 \
+    /* || defined(__GNUC__) && __GNUC__ >= 9 */
+  #define Z7_final  final
+  #if defined(__clang__) && __cplusplus < 201103L
+    #pragma GCC diagnostic ignored "-Wc++11-extensions"
+  #endif
+#elif defined (__cplusplus) && __cplusplus >= 199711L \
+    && defined(__GNUC__) && __GNUC__ >= 4 && !defined(__clang__)
+  #define Z7_final __final
+#else
+  #define Z7_final
+  #if defined(__clang__) && __clang_major__ >= 4 \
+     || defined(__GNUC__) && __GNUC__ >= 4
+    #pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
+    #pragma GCC diagnostic ignored "-Wdelete-non-virtual-dtor"
+  #endif
+#endif
+
+#define Z7_class_final(c)  class c Z7_final
+
+
+#if defined (__cplusplus) && __cplusplus >= 201103L \
+    || (defined(_MSC_VER) && _MSC_VER >= 1800)
+  #define Z7_CPP_IS_SUPPORTED_default
+  #define Z7_eq_delete  = delete
+  // #define Z7_DECL_DEFAULT_COPY_CONSTRUCTOR_IF_SUPPORTED(c) c(const c& k) = default;
+#else
+  #define Z7_eq_delete
+  // #define Z7_DECL_DEFAULT_COPY_CONSTRUCTOR_IF_SUPPORTED(c)
+#endif
+
+
+#if defined(__cplusplus) && (__cplusplus >= 201103L) \
+    || defined(_MSC_VER) && (_MSC_VER >= 1400) /* && (_MSC_VER != 1600) */ \
+    || defined(__clang__) && __clang_major__ >= 4
+  #if defined(_MSC_VER) && (_MSC_VER == 1600) /* && (_MSC_VER != 1600) */
+    #pragma warning(disable : 4481) // nonstandard extension used: override specifier 'override'
+    #define Z7_DESTRUCTOR_override
+  #else
+    #define Z7_DESTRUCTOR_override  override
+  #endif
+  #define Z7_override  override
+#else
+  #define Z7_override
+  #define Z7_DESTRUCTOR_override
+#endif
+
+
+
+#define Z7_CLASS_NO_COPY(cls) \
+  private: \
+  cls(const cls &) Z7_eq_delete; \
+  cls &operator=(const cls &) Z7_eq_delete;
+
+class CUncopyable
+{
+protected:
+  CUncopyable() {} // allow constructor
+  // ~CUncopyable() {}
+  Z7_CLASS_NO_COPY(CUncopyable)
+};
+
+#define MY_UNCOPYABLE  :private CUncopyable
+// #define MY_UNCOPYABLE
+
+
+// typedef void (*Z7_void_Function)(void);
+
+#if defined(__clang__) || defined(__GNUC__)
+#define Z7_CAST_FUNC(t, e) reinterpret_cast<t>(reinterpret_cast<Z7_void_Function>(e))
+#else
+#define Z7_CAST_FUNC(t, e) reinterpret_cast<t>(reinterpret_cast<void*>(e))
+// #define Z7_CAST_FUNC(t, e) reinterpret_cast<t>(e)
+#endif
+
+#define Z7_GET_PROC_ADDRESS(func_type, hmodule, func_name)  \
+    Z7_CAST_FUNC(func_type, GetProcAddress(hmodule, func_name))
+
+// || defined(__clang__)
+// || defined(__GNUC__)
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1400)
+#define Z7_DECLSPEC_NOVTABLE __declspec(novtable)
+#else
+#define Z7_DECLSPEC_NOVTABLE
+#endif
+
+#ifdef __clang__
+#define Z7_PURE_INTERFACES_BEGIN \
+_Pragma("GCC diagnostic push") \
+_Pragma("GCC diagnostic ignored \"-Wnon-virtual-dtor\"")
+_Pragma("GCC diagnostic ignored \"-Wweak-vtables\"")
+#define Z7_PURE_INTERFACES_END \
+_Pragma("GCC diagnostic pop")
+#else
+#define Z7_PURE_INTERFACES_BEGIN
+#define Z7_PURE_INTERFACES_END
+#endif
+
+// NewHandler.h and NewHandler.cpp redefine operator new() to throw exceptions, if compiled with old MSVC compilers
+#include "NewHandler.h"
+
+/*
+// #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
+#ifndef ARRAY_SIZE
+#define ARRAY_SIZE(a)  Z7_ARRAY_SIZE(a)
+#endif
+*/
+
+#endif // ZIP7_INC_COMMON0_H
+
+
+
+// #define Z7_REDEFINE_NULL
+
+#if defined(Z7_REDEFINE_NULL) /* && (!defined(__clang__) || defined(_MSC_VER)) */
+
+// NULL is defined in <stddef.h>
+#include <stddef.h>
+#undef NULL
+
+#ifdef __cplusplus
+  #if defined (__cplusplus) && __cplusplus >= 201103L \
+    || (defined(_MSC_VER) && _MSC_VER >= 1800)
+    #define NULL  nullptr
+  #else
+    #define NULL  0
+  #endif
+#else
+  #define NULL  ((void *)0)
+#endif
+
+#else // Z7_REDEFINE_NULL
+
+#if defined(__clang__) && __clang_major__ >= 5
+#pragma GCC diagnostic ignored "-Wzero-as-null-pointer-constant"
+#endif
+
+#endif // Z7_REDEFINE_NULL
+
+// for precompiler:
+// #include "MyWindows.h"
diff --git a/libs/archive/thirdparty/CPP/Common/MyGuidDef.h b/libs/archive/thirdparty/CPP/Common/MyGuidDef.h
new file mode 100644
index 0000000..3aa5266
--- /dev/null
+++ b/libs/archive/thirdparty/CPP/Common/MyGuidDef.h
@@ -0,0 +1,63 @@
+// Common/MyGuidDef.h
+
+// #pragma message "Common/MyGuidDef.h"
+
+#ifndef GUID_DEFINED
+#define GUID_DEFINED
+
+// #pragma message "GUID_DEFINED"
+
+#include "MyTypes.h"
+
+typedef struct {
+  UInt32 Data1;
+  UInt16 Data2;
+  UInt16 Data3;
+  Byte Data4[8];
+} GUID;
+
+#ifdef __cplusplus
+#define REFGUID const GUID &
+#else
+#define REFGUID const GUID *
+#endif
+
+// typedef GUID IID;
+typedef GUID CLSID;
+
+#define REFCLSID REFGUID
+#define REFIID REFGUID
+
+#ifdef __cplusplus
+inline int operator==(REFGUID g1, REFGUID g2)
+{
+  for (unsigned i = 0; i < sizeof(g1); i++)
+    if (((const Byte *)&g1)[i] != ((const Byte *)&g2)[i])
+      return 0;
+  return 1;
+}
+inline int operator!=(REFGUID g1, REFGUID g2) { return !(g1 == g2); }
+#endif
+
+#endif // GUID_DEFINED
+
+#ifndef EXTERN_C
+#ifdef __cplusplus
+  #define EXTERN_C extern "C"
+#else
+  #define EXTERN_C extern
+#endif
+#endif
+
+#ifdef DEFINE_GUID
+#undef DEFINE_GUID
+#endif
+
+#ifdef INITGUID
+  #define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
+    EXTERN_C const GUID name; \
+    EXTERN_C const GUID name = { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } }
+#else
+  #define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
+    EXTERN_C const GUID name
+#endif
diff --git a/libs/archive/thirdparty/CPP/Common/MyTypes.h b/libs/archive/thirdparty/CPP/Common/MyTypes.h
new file mode 100644
index 0000000..eadc9a4
--- /dev/null
+++ b/libs/archive/thirdparty/CPP/Common/MyTypes.h
@@ -0,0 +1,38 @@
+// Common/MyTypes.h
+
+#ifndef ZIP7_INC_COMMON_MY_TYPES_H
+#define ZIP7_INC_COMMON_MY_TYPES_H
+
+#include "Common0.h"
+#include "../../C/7zTypes.h"
+
+// typedef int HRes;
+// typedef HRESULT HRes;
+
+struct CBoolPair
+{
+  bool Val;
+  bool Def;
+
+  CBoolPair(): Val(false), Def(false) {}
+  
+  void Init()
+  {
+    Val = false;
+    Def = false;
+  }
+
+  void SetTrueTrue()
+  {
+    Val = true;
+    Def = true;
+  }
+
+  void SetVal_as_Defined(bool val)
+  {
+    Val = val;
+    Def = true;
+  }
+};
+
+#endif
diff --git a/libs/archive/thirdparty/CPP/Common/MyUnknown.h b/libs/archive/thirdparty/CPP/Common/MyUnknown.h
new file mode 100644
index 0000000..75ee96f
--- /dev/null
+++ b/libs/archive/thirdparty/CPP/Common/MyUnknown.h
@@ -0,0 +1,8 @@
+// MyUnknown.h
+
+#ifndef ZIP7_INC_MY_UNKNOWN_H
+#define ZIP7_INC_MY_UNKNOWN_H
+
+#include "MyWindows.h"
+
+#endif
diff --git a/libs/archive/thirdparty/CPP/Common/MyWindows.cpp b/libs/archive/thirdparty/CPP/Common/MyWindows.cpp
new file mode 100644
index 0000000..a1dfbef
--- /dev/null
+++ b/libs/archive/thirdparty/CPP/Common/MyWindows.cpp
@@ -0,0 +1,292 @@
+// MyWindows.cpp
+
+#include "StdAfx.h"
+
+#ifndef _WIN32
+
+#include <stdlib.h>
+#include <time.h>
+#ifdef __GNUC__
+#include <sys/time.h>
+#endif
+
+#include "MyWindows.h"
+
+static inline void *AllocateForBSTR(size_t cb) { return ::malloc(cb); }
+static inline void FreeForBSTR(void *pv) { ::free(pv);}
+
+/* Win32 uses DWORD (32-bit) type to store size of string before (OLECHAR *) string.
+  We must select CBstrSizeType for another systems (not Win32):
+
+    if (CBstrSizeType is UINT32),
+          then we support only strings smaller than 4 GB.
+          Win32 version always has that limitation.
+  
+    if (CBstrSizeType is UINT),
+          (UINT can be 16/32/64-bit)
+          We can support strings larger than 4 GB (if UINT is 64-bit),
+          but sizeof(UINT) can be different in parts compiled by
+          different compilers/settings,
+          and we can't send such BSTR strings between such parts.
+*/
+
+typedef UINT32 CBstrSizeType;
+// typedef UINT CBstrSizeType;
+
+#define k_BstrSize_Max 0xFFFFFFFF
+// #define k_BstrSize_Max UINT_MAX
+// #define k_BstrSize_Max ((UINT)(INT)-1)
+
+BSTR SysAllocStringByteLen(LPCSTR s, UINT len)
+{
+  /* Original SysAllocStringByteLen in Win32 maybe fills only unaligned null OLECHAR at the end.
+     We provide also aligned null OLECHAR at the end. */
+
+  if (len >= (k_BstrSize_Max - (UINT)sizeof(OLECHAR) - (UINT)sizeof(OLECHAR) - (UINT)sizeof(CBstrSizeType)))
+    return NULL;
+
+  UINT size = (len + (UINT)sizeof(OLECHAR) + (UINT)sizeof(OLECHAR) - 1) & ~((UINT)sizeof(OLECHAR) - 1);
+  void *p = AllocateForBSTR(size + (UINT)sizeof(CBstrSizeType));
+  if (!p)
+    return NULL;
+  *(CBstrSizeType *)p = (CBstrSizeType)len;
+  BSTR bstr = (BSTR)((CBstrSizeType *)p + 1);
+  if (s)
+    memcpy(bstr, s, len);
+  for (; len < size; len++)
+    ((Byte *)bstr)[len] = 0;
+  return bstr;
+}
+
+BSTR SysAllocStringLen(const OLECHAR *s, UINT len)
+{
+  if (len >= (k_BstrSize_Max - (UINT)sizeof(OLECHAR) - (UINT)sizeof(CBstrSizeType)) / (UINT)sizeof(OLECHAR))
+    return NULL;
+
+  UINT size = len * (UINT)sizeof(OLECHAR);
+  void *p = AllocateForBSTR(size + (UINT)sizeof(CBstrSizeType) + (UINT)sizeof(OLECHAR));
+  if (!p)
+    return NULL;
+  *(CBstrSizeType *)p = (CBstrSizeType)size;
+  BSTR bstr = (BSTR)((CBstrSizeType *)p + 1);
+  if (s)
+    memcpy(bstr, s, size);
+  bstr[len] = 0;
+  return bstr;
+}
+
+BSTR SysAllocString(const OLECHAR *s)
+{
+  if (!s)
+    return NULL;
+  const OLECHAR *s2 = s;
+  while (*s2 != 0)
+    s2++;
+  return SysAllocStringLen(s, (UINT)(s2 - s));
+}
+
+void SysFreeString(BSTR bstr)
+{
+  if (bstr)
+    FreeForBSTR((CBstrSizeType *)(void *)bstr - 1);
+}
+
+UINT SysStringByteLen(BSTR bstr)
+{
+  if (!bstr)
+    return 0;
+  return *((CBstrSizeType *)(void *)bstr - 1);
+}
+
+UINT SysStringLen(BSTR bstr)
+{
+  if (!bstr)
+    return 0;
+  return *((CBstrSizeType *)(void *)bstr - 1) / (UINT)sizeof(OLECHAR);
+}
+
+
+HRESULT VariantClear(VARIANTARG *prop)
+{
+  if (prop->vt == VT_BSTR)
+    SysFreeString(prop->bstrVal);
+  prop->vt = VT_EMPTY;
+  return S_OK;
+}
+
+HRESULT VariantCopy(VARIANTARG *dest, const VARIANTARG *src)
+{
+  HRESULT res = ::VariantClear(dest);
+  if (res != S_OK)
+    return res;
+  if (src->vt == VT_BSTR)
+  {
+    dest->bstrVal = SysAllocStringByteLen((LPCSTR)src->bstrVal,
+        SysStringByteLen(src->bstrVal));
+    if (!dest->bstrVal)
+      return E_OUTOFMEMORY;
+    dest->vt = VT_BSTR;
+  }
+  else
+    *dest = *src;
+  return S_OK;
+}
+
+LONG CompareFileTime(const FILETIME* ft1, const FILETIME* ft2)
+{
+  if (ft1->dwHighDateTime < ft2->dwHighDateTime) return -1;
+  if (ft1->dwHighDateTime > ft2->dwHighDateTime) return 1;
+  if (ft1->dwLowDateTime < ft2->dwLowDateTime) return -1;
+  if (ft1->dwLowDateTime > ft2->dwLowDateTime) return 1;
+  return 0;
+}
+
+DWORD GetLastError()
+{
+  return (DWORD)errno;
+}
+
+void SetLastError(DWORD dw)
+{
+  errno = (int)dw;
+}
+
+
+static LONG TIME_GetBias()
+{
+  time_t utc = time(NULL);
+  struct tm *ptm = localtime(&utc);
+  int localdaylight = ptm->tm_isdst; /* daylight for local timezone */
+  ptm = gmtime(&utc);
+  ptm->tm_isdst = localdaylight; /* use local daylight, not that of Greenwich */
+  LONG bias = (int)(mktime(ptm)-utc);
+  return bias;
+}
+
+#define TICKS_PER_SEC 10000000
+/*
+#define SECS_PER_DAY (24 * 60 * 60)
+#define SECS_1601_TO_1970  ((369 * 365 + 89) * (UInt64)SECS_PER_DAY)
+#define TICKS_1601_TO_1970 (SECS_1601_TO_1970 * TICKS_PER_SEC)
+*/
+
+#define GET_TIME_64(pft) ((pft)->dwLowDateTime | ((UInt64)(pft)->dwHighDateTime << 32))
+
+#define SET_FILETIME(ft, v64) \
+   (ft)->dwLowDateTime = (DWORD)v64; \
+   (ft)->dwHighDateTime = (DWORD)(v64 >> 32);
+
+
+BOOL WINAPI FileTimeToLocalFileTime(const FILETIME *fileTime, FILETIME *localFileTime)
+{
+  UInt64 v = GET_TIME_64(fileTime);
+  v = (UInt64)((Int64)v - (Int64)TIME_GetBias() * TICKS_PER_SEC);
+  SET_FILETIME(localFileTime, v)
+  return TRUE;
+}
+
+BOOL WINAPI LocalFileTimeToFileTime(const FILETIME *localFileTime, FILETIME *fileTime)
+{
+  UInt64 v = GET_TIME_64(localFileTime);
+  v = (UInt64)((Int64)v + (Int64)TIME_GetBias() * TICKS_PER_SEC);
+  SET_FILETIME(fileTime, v)
+  return TRUE;
+}
+
+/*
+VOID WINAPI GetSystemTimeAsFileTime(FILETIME *ft)
+{
+  UInt64 t = 0;
+  timeval tv;
+  if (gettimeofday(&tv, NULL) == 0)
+  {
+    t = tv.tv_sec * (UInt64)TICKS_PER_SEC + TICKS_1601_TO_1970;
+    t += tv.tv_usec * 10;
+  }
+  SET_FILETIME(ft, t)
+}
+*/
+
+DWORD WINAPI GetTickCount(VOID)
+{
+  #ifndef _WIN32
+  // gettimeofday() doesn't work in some MINGWs by unknown reason
+  timeval tv;
+  if (gettimeofday(&tv, NULL) == 0)
+  {
+    // tv_sec and tv_usec are (long)
+    return (DWORD)((UInt64)(Int64)tv.tv_sec * (UInt64)1000 + (UInt64)(Int64)tv.tv_usec / 1000);
+  }
+  #endif
+  return (DWORD)time(NULL) * 1000;
+}
+
+
+#define PERIOD_4 (4 * 365 + 1)
+#define PERIOD_100 (PERIOD_4 * 25 - 1)
+#define PERIOD_400 (PERIOD_100 * 4 + 1)
+
+BOOL WINAPI FileTimeToSystemTime(const FILETIME *ft, SYSTEMTIME *st)
+{
+  UInt32 v;
+  UInt64 v64 = GET_TIME_64(ft);
+  v64 /= 10000;
+  st->wMilliseconds = (WORD)(v64 % 1000); v64 /= 1000;
+  st->wSecond       = (WORD)(v64 %   60); v64 /= 60;
+  st->wMinute       = (WORD)(v64 %   60); v64 /= 60;
+  v = (UInt32)v64;
+  st->wHour         = (WORD)(v %   24); v /= 24;
+
+  // 1601-01-01 was Monday
+  st->wDayOfWeek = (WORD)((v + 1) % 7);
+
+  UInt32 leaps, year, day, mon;
+  leaps = (3 * ((4 * v + (365 - 31 - 28) * 4 + 3) / PERIOD_400) + 3) / 4;
+  v += 28188 + leaps;
+  // leaps - the number of exceptions from PERIOD_4 rules starting from 1600-03-01
+  // (1959 / 64) - converts day from 03-01 to month
+  year = (20 * v - 2442) / (5 * PERIOD_4);
+  day = v - (year * PERIOD_4) / 4;
+  mon = (64 * day) / 1959;
+  st->wDay = (WORD)(day - (1959 * mon) / 64);
+  mon -= 1;
+  year += 1524;
+  if (mon > 12)
+  {
+    mon -= 12;
+    year++;
+  }
+  st->wMonth = (WORD)mon;
+  st->wYear = (WORD)year;
+
+  /*
+  unsigned year, mon;
+  unsigned char ms[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+  unsigned t;
+
+  year = (WORD)(1601 + v / PERIOD_400 * 400);
+  v %= PERIOD_400;
+
+  t = v / PERIOD_100; if (t ==  4) t =  3; year += t * 100; v -= t * PERIOD_100;
+  t = v / PERIOD_4;   if (t == 25) t = 24; year += t * 4;   v -= t * PERIOD_4;
+  t = v / 365;        if (t ==  4) t =  3; year += t;       v -= t * 365;
+
+  st->wYear = (WORD)year;
+
+  if (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0))
+    ms[1] = 29;
+  for (mon = 0;; mon++)
+  {
+    unsigned d = ms[mon];
+    if (v < d)
+      break;
+    v -= d;
+  }
+  st->wDay = (WORD)(v + 1);
+  st->wMonth = (WORD)(mon + 1);
+  */
+
+  return TRUE;
+}
+
+#endif
diff --git a/libs/archive/thirdparty/CPP/Common/MyWindows.h b/libs/archive/thirdparty/CPP/Common/MyWindows.h
new file mode 100644
index 0000000..da5370b
--- /dev/null
+++ b/libs/archive/thirdparty/CPP/Common/MyWindows.h
@@ -0,0 +1,325 @@
+// MyWindows.h
+
+#ifdef Z7_DEFINE_GUID
+#undef Z7_DEFINE_GUID
+#endif
+
+#ifdef INITGUID
+  #define Z7_DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
+    EXTERN_C const GUID name; \
+    EXTERN_C const GUID name = { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } }
+#else
+  #define Z7_DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
+    EXTERN_C const GUID name
+#endif
+
+
+#ifndef ZIP7_INC_MY_WINDOWS_H
+#define ZIP7_INC_MY_WINDOWS_H
+
+#ifdef _WIN32
+
+#include "../../C/7zWindows.h"
+
+#else // _WIN32
+
+#include <stddef.h> // for wchar_t
+#include <string.h>
+// #include <stdint.h> // for uintptr_t
+
+#include "../../C/7zTypes.h"
+#include "MyGuidDef.h"
+
+// WINAPI is __stdcall in Windows-MSVC in windef.h
+#define WINAPI
+
+typedef char CHAR;
+typedef unsigned char UCHAR;
+
+#undef BYTE
+typedef unsigned char BYTE;
+
+typedef short SHORT;
+typedef unsigned short USHORT;
+
+#undef WORD
+typedef unsigned short WORD;
+typedef short VARIANT_BOOL;
+
+#define LOWORD(l) ((WORD)((DWORD_PTR)(l) & 0xffff))
+#define HIWORD(l) ((WORD)((DWORD_PTR)(l) >> 16))
+
+// MS uses long for BOOL, but long is 32-bit in MS. So we use int.
+// typedef long BOOL;
+typedef int BOOL;
+
+#ifndef FALSE
+  #define FALSE 0
+  #define TRUE 1
+#endif
+
+// typedef size_t ULONG_PTR;
+// typedef size_t DWORD_PTR;
+// typedef uintptr_t UINT_PTR;
+// typedef ptrdiff_t UINT_PTR;
+
+typedef Int64 LONGLONG;
+typedef UInt64 ULONGLONG;
+
+typedef struct { LONGLONG QuadPart; } LARGE_INTEGER;
+typedef struct { ULONGLONG QuadPart; } ULARGE_INTEGER;
+
+typedef const CHAR *LPCSTR;
+typedef CHAR TCHAR;
+typedef const TCHAR *LPCTSTR;
+typedef wchar_t WCHAR;
+typedef WCHAR OLECHAR;
+typedef const WCHAR *LPCWSTR;
+typedef OLECHAR *BSTR;
+typedef const OLECHAR *LPCOLESTR;
+typedef OLECHAR *LPOLESTR;
+
+typedef struct
+{
+  DWORD dwLowDateTime;
+  DWORD dwHighDateTime;
+} FILETIME;
+
+#define SUCCEEDED(hr) ((HRESULT)(hr) >= 0)
+#define FAILED(hr)    ((HRESULT)(hr) < 0)
+typedef ULONG PROPID;
+typedef LONG SCODE;
+
+
+#define S_OK    ((HRESULT)0x00000000L)
+#define S_FALSE ((HRESULT)0x00000001L)
+#define E_NOTIMPL     ((HRESULT)0x80004001L)
+#define E_NOINTERFACE ((HRESULT)0x80004002L)
+#define E_ABORT       ((HRESULT)0x80004004L)
+#define E_FAIL        ((HRESULT)0x80004005L)
+#define STG_E_INVALIDFUNCTION     ((HRESULT)0x80030001L)
+#define CLASS_E_CLASSNOTAVAILABLE ((HRESULT)0x80040111L)
+
+
+#ifdef _MSC_VER
+#define STDMETHODCALLTYPE __stdcall
+#define STDAPICALLTYPE    __stdcall
+#else
+// do we need __export here?
+#define STDMETHODCALLTYPE
+#define STDAPICALLTYPE
+#endif
+
+#define STDAPI  EXTERN_C HRESULT STDAPICALLTYPE
+
+#ifndef DECLSPEC_NOTHROW
+#define DECLSPEC_NOTHROW    Z7_DECLSPEC_NOTHROW
+#endif
+
+#ifndef DECLSPEC_NOVTABLE
+#define DECLSPEC_NOVTABLE   Z7_DECLSPEC_NOVTABLE
+#endif
+
+#ifndef COM_DECLSPEC_NOTHROW
+#ifdef COM_STDMETHOD_CAN_THROW
+  #define COM_DECLSPEC_NOTHROW
+#else
+  #define COM_DECLSPEC_NOTHROW  DECLSPEC_NOTHROW
+#endif
+#endif
+
+#define DECLARE_INTERFACE(iface)              struct DECLSPEC_NOVTABLE iface
+#define DECLARE_INTERFACE_(iface, baseiface)  struct DECLSPEC_NOVTABLE iface : public baseiface
+
+#define STDMETHOD_(t, f)  virtual COM_DECLSPEC_NOTHROW t STDMETHODCALLTYPE f
+#define STDMETHOD(f)      STDMETHOD_(HRESULT, f)
+#define STDMETHODIMP_(t)  COM_DECLSPEC_NOTHROW t STDMETHODCALLTYPE
+#define STDMETHODIMP      STDMETHODIMP_(HRESULT)
+
+
+#define PURE = 0
+
+// #define MIDL_INTERFACE(x) struct
+
+
+#ifdef __cplusplus
+
+/*
+  p7zip and 7-Zip before v23 used virtual destructor in IUnknown,
+  if _WIN32 is not defined.
+  It used virtual destructor, because some compilers don't like virtual
+  interfaces without virtual destructor.
+  IUnknown in Windows (_WIN32) doesn't use virtual destructor in IUnknown.
+  We still can define Z7_USE_VIRTUAL_DESTRUCTOR_IN_IUNKNOWN here,
+  if we want to be compatible with old plugin interface of p7zip and 7-Zip before v23.
+
+v23:
+  In new 7-Zip v23 we try to be more compatible with original IUnknown from _WIN32.
+  So we do not define Z7_USE_VIRTUAL_DESTRUCTOR_IN_IUNKNOWN here,
+*/
+// #define Z7_USE_VIRTUAL_DESTRUCTOR_IN_IUNKNOWN
+
+#ifdef Z7_USE_VIRTUAL_DESTRUCTOR_IN_IUNKNOWN
+#if defined(__clang__)
+#pragma GCC diagnostic ignored "-Winconsistent-missing-destructor-override"
+#endif
+#endif
+
+Z7_PURE_INTERFACES_BEGIN
+
+DEFINE_GUID(IID_IUnknown,
+0x00000000, 0x0000, 0x0000, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46);
+struct IUnknown
+{
+  STDMETHOD(QueryInterface) (REFIID iid, void **outObject) =0;
+  STDMETHOD_(ULONG, AddRef)() =0;
+  STDMETHOD_(ULONG, Release)() =0;
+ #ifdef Z7_USE_VIRTUAL_DESTRUCTOR_IN_IUNKNOWN
+  virtual ~IUnknown() {}
+ #endif
+};
+
+typedef IUnknown *LPUNKNOWN;
+
+Z7_PURE_INTERFACES_END
+
+#endif // __cplusplus
+
+#define VARIANT_TRUE ((VARIANT_BOOL)-1)
+#define VARIANT_FALSE ((VARIANT_BOOL)0)
+
+enum VARENUM
+{
+  VT_EMPTY = 0,
+  VT_NULL = 1,
+  VT_I2 = 2,
+  VT_I4 = 3,
+  VT_R4 = 4,
+  VT_R8 = 5,
+  VT_CY = 6,
+  VT_DATE = 7,
+  VT_BSTR = 8,
+  VT_DISPATCH = 9,
+  VT_ERROR = 10,
+  VT_BOOL = 11,
+  VT_VARIANT = 12,
+  VT_UNKNOWN = 13,
+  VT_DECIMAL = 14,
+
+  VT_I1 = 16,
+  VT_UI1 = 17,
+  VT_UI2 = 18,
+  VT_UI4 = 19,
+  VT_I8 = 20,
+  VT_UI8 = 21,
+  VT_INT = 22,
+  VT_UINT = 23,
+  VT_VOID = 24,
+  VT_HRESULT = 25,
+  VT_FILETIME = 64
+};
+
+typedef unsigned short VARTYPE;
+typedef WORD PROPVAR_PAD1;
+typedef WORD PROPVAR_PAD2;
+typedef WORD PROPVAR_PAD3;
+
+typedef struct tagPROPVARIANT
+{
+  VARTYPE vt;
+  PROPVAR_PAD1 wReserved1;
+  PROPVAR_PAD2 wReserved2;
+  PROPVAR_PAD3 wReserved3;
+  union
+  {
+    CHAR cVal;
+    UCHAR bVal;
+    SHORT iVal;
+    USHORT uiVal;
+    LONG lVal;
+    ULONG ulVal;
+    INT intVal;
+    UINT uintVal;
+    LARGE_INTEGER hVal;
+    ULARGE_INTEGER uhVal;
+    VARIANT_BOOL boolVal;
+    SCODE scode;
+    FILETIME filetime;
+    BSTR bstrVal;
+  };
+} PROPVARIANT;
+
+typedef PROPVARIANT tagVARIANT;
+typedef tagVARIANT VARIANT;
+typedef VARIANT VARIANTARG;
+
+EXTERN_C HRESULT VariantClear(VARIANTARG *prop);
+EXTERN_C HRESULT VariantCopy(VARIANTARG *dest, const VARIANTARG *src);
+
+typedef struct tagSTATPROPSTG
+{
+  LPOLESTR lpwstrName;
+  PROPID propid;
+  VARTYPE vt;
+} STATPROPSTG;
+
+EXTERN_C BSTR SysAllocStringByteLen(LPCSTR psz, UINT len);
+EXTERN_C BSTR SysAllocStringLen(const OLECHAR *sz, UINT len);
+EXTERN_C BSTR SysAllocString(const OLECHAR *sz);
+EXTERN_C void SysFreeString(BSTR bstr);
+EXTERN_C UINT SysStringByteLen(BSTR bstr);
+EXTERN_C UINT SysStringLen(BSTR bstr);
+
+EXTERN_C DWORD GetLastError();
+EXTERN_C void SetLastError(DWORD dwCode);
+EXTERN_C LONG CompareFileTime(const FILETIME* ft1, const FILETIME* ft2);
+
+EXTERN_C DWORD GetCurrentThreadId();
+EXTERN_C DWORD GetCurrentProcessId();
+
+#define MAX_PATH 1024
+
+#define CP_ACP    0
+#define CP_OEMCP  1
+#define CP_UTF8   65001
+
+typedef enum tagSTREAM_SEEK
+{
+  STREAM_SEEK_SET = 0,
+  STREAM_SEEK_CUR = 1,
+  STREAM_SEEK_END = 2
+} STREAM_SEEK;
+
+
+
+typedef struct
+{
+  WORD wYear;
+  WORD wMonth;
+  WORD wDayOfWeek;
+  WORD wDay;
+  WORD wHour;
+  WORD wMinute;
+  WORD wSecond;
+  WORD wMilliseconds;
+} SYSTEMTIME;
+
+BOOL WINAPI FileTimeToLocalFileTime(const FILETIME *fileTime, FILETIME *localFileTime);
+BOOL WINAPI LocalFileTimeToFileTime(const FILETIME *localFileTime, FILETIME *fileTime);
+BOOL WINAPI FileTimeToSystemTime(const FILETIME *fileTime, SYSTEMTIME *systemTime);
+// VOID WINAPI GetSystemTimeAsFileTime(FILETIME *systemTimeAsFileTime);
+
+DWORD GetTickCount();
+
+
+/*
+#define CREATE_NEW          1
+#define CREATE_ALWAYS       2
+#define OPEN_EXISTING       3
+#define OPEN_ALWAYS         4
+#define TRUNCATE_EXISTING   5
+*/
+
+#endif // _WIN32
+
+#endif
diff --git a/libs/archive/thirdparty/CPP/Common/NewHandler.h b/libs/archive/thirdparty/CPP/Common/NewHandler.h
new file mode 100644
index 0000000..5ba64b7
--- /dev/null
+++ b/libs/archive/thirdparty/CPP/Common/NewHandler.h
@@ -0,0 +1,121 @@
+// Common/NewHandler.h
+
+#ifndef ZIP7_INC_COMMON_NEW_HANDLER_H
+#define ZIP7_INC_COMMON_NEW_HANDLER_H
+
+/*
+NewHandler.h and NewHandler.cpp allows to solve problem with compilers that
+don't throw exception in operator new().
+
+This file must be included before any code that uses operators new() or delete()
+and you must compile and link "NewHandler.cpp", if you use some old MSVC compiler.
+
+DOCs:
+  Since ISO C++98, operator new throws std::bad_alloc when memory allocation fails.
+  MSVC 6.0 returned a null pointer on an allocation failure.
+  Beginning in VS2002, operator new conforms to the standard and throws on failure.
+
+  By default, the compiler also generates defensive null checks to prevent
+  these older-style allocators from causing an immediate crash on failure.
+  The /Zc:throwingNew option tells the compiler to leave out these null checks,
+  on the assumption that all linked memory allocators conform to the standard.
+
+The operator new() in some MSVC versions doesn't throw exception std::bad_alloc.
+MSVC 6.0 (_MSC_VER == 1200) doesn't throw exception.
+The code produced by some another MSVC compilers also can be linked
+to library that doesn't throw exception.
+We suppose that code compiled with VS2015+ (_MSC_VER >= 1900) throws exception std::bad_alloc.
+For older _MSC_VER versions we redefine operator new() and operator delete().
+Our version of operator new() throws CNewException() exception on failure.
+
+It's still allowed to use redefined version of operator new() from "NewHandler.cpp"
+with any compiler. 7-Zip's code can work with std::bad_alloc and CNewException() exceptions.
+But if you use some additional code (outside of 7-Zip's code), you must check
+that redefined version of operator new() is not problem for your code.
+*/
+
+#include <stddef.h>
+
+#ifdef _WIN32
+// We can compile my_new and my_delete with _fastcall
+/*
+void * my_new(size_t size);
+void my_delete(void *p) throw();
+// void * my_Realloc(void *p, size_t newSize, size_t oldSize);
+*/
+#endif
+
+
+#if defined(_MSC_VER) && (_MSC_VER < 1600)
+  // If you want to use default operator new(), you can disable the following line
+  #define Z7_REDEFINE_OPERATOR_NEW
+#endif
+
+
+#ifdef Z7_REDEFINE_OPERATOR_NEW
+
+// std::bad_alloc can require additional DLL dependency.
+// So we don't define CNewException as std::bad_alloc here.
+
+class CNewException {};
+
+void *
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator new(size_t size);
+
+/*
+#if 0 && defined(_MSC_VER) && _MSC_VER == 1600
+  #define Z7_OPERATOR_DELETE_SPEC_THROW0
+#else
+  #define Z7_OPERATOR_DELETE_SPEC_THROW0 throw()
+#endif
+*/
+#if defined(_MSC_VER) && _MSC_VER == 1600
+#pragma warning(push)
+#pragma warning(disable : 4986) // 'operator delete': exception specification does not match previous declaration
+#endif
+
+void
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator delete(void *p) throw();
+
+void
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator delete(void *p, size_t n) throw();
+
+#if defined(_MSC_VER) && _MSC_VER == 1600
+#pragma warning(pop)
+#endif
+
+
+#else
+
+#include <new>
+
+#define CNewException std::bad_alloc
+
+#endif
+
+/*
+#ifdef _WIN32
+void *
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator new[](size_t size);
+
+void
+#ifdef _MSC_VER
+__cdecl
+#endif
+operator delete[](void *p) throw();
+#endif
+*/
+
+#endif
diff --git a/libs/archive/thirdparty/CPP/Common/StdAfx.h b/libs/archive/thirdparty/CPP/Common/StdAfx.h
new file mode 100644
index 0000000..a5228b0
--- /dev/null
+++ b/libs/archive/thirdparty/CPP/Common/StdAfx.h
@@ -0,0 +1,8 @@
+// StdAfx.h
+
+#ifndef ZIP7_INC_STDAFX_H
+#define ZIP7_INC_STDAFX_H
+
+#include "Common.h"
+
+#endif