Vendor dependencies for 0.3.0 release

vendor/windows-core-0.58.0/src/imp/bindings.rs

@@ -0,0 +1,671 @@
+#![allow(
+    non_snake_case,
+    non_upper_case_globals,
+    non_camel_case_types,
+    dead_code,
+    clippy::all
+)]
+windows_targets::link!("api-ms-win-core-winrt-l1-1-0.dll" "system" fn RoGetActivationFactory(activatableclassid : * mut core::ffi::c_void, iid : *const GUID, factory : *mut *mut core::ffi::c_void) -> HRESULT);
+windows_targets::link!("kernel32.dll" "system" fn CloseHandle(hobject : HANDLE) -> BOOL);
+windows_targets::link!("kernel32.dll" "system" fn CreateEventW(lpeventattributes : *const SECURITY_ATTRIBUTES, bmanualreset : BOOL, binitialstate : BOOL, lpname : PCWSTR) -> HANDLE);
+windows_targets::link!("kernel32.dll" "system" fn EncodePointer(ptr : *const core::ffi::c_void) -> *mut core::ffi::c_void);
+windows_targets::link!("kernel32.dll" "system" fn FreeLibrary(hlibmodule : HMODULE) -> BOOL);
+windows_targets::link!("kernel32.dll" "system" fn GetProcAddress(hmodule : HMODULE, lpprocname : PCSTR) -> FARPROC);
+windows_targets::link!("kernel32.dll" "system" fn LoadLibraryExA(lplibfilename : PCSTR, hfile : HANDLE, dwflags : LOAD_LIBRARY_FLAGS) -> HMODULE);
+windows_targets::link!("kernel32.dll" "system" fn SetEvent(hevent : HANDLE) -> BOOL);
+windows_targets::link!("kernel32.dll" "system" fn WaitForSingleObject(hhandle : HANDLE, dwmilliseconds : u32) -> WAIT_EVENT);
+windows_targets::link!("ole32.dll" "system" fn CoIncrementMTAUsage(pcookie : *mut CO_MTA_USAGE_COOKIE) -> HRESULT);
+windows_targets::link!("ole32.dll" "system" fn CoTaskMemAlloc(cb : usize) -> *mut core::ffi::c_void);
+windows_targets::link!("ole32.dll" "system" fn CoTaskMemFree(pv : *const core::ffi::c_void));
+windows_targets::link!("ole32.dll" "system" fn PropVariantClear(pvar : *mut PROPVARIANT) -> HRESULT);
+windows_targets::link!("ole32.dll" "system" fn PropVariantCopy(pvardest : *mut PROPVARIANT, pvarsrc : *const PROPVARIANT) -> HRESULT);
+windows_targets::link!("oleaut32.dll" "system" fn VariantClear(pvarg : *mut VARIANT) -> HRESULT);
+windows_targets::link!("oleaut32.dll" "system" fn VariantCopy(pvargdest : *mut VARIANT, pvargsrc : *const VARIANT) -> HRESULT);
+windows_targets::link!("propsys.dll" "system" fn PropVariantCompareEx(propvar1 : *const PROPVARIANT, propvar2 : *const PROPVARIANT, unit : PROPVAR_COMPARE_UNIT, flags : PROPVAR_COMPARE_FLAGS) -> i32);
+windows_targets::link!("propsys.dll" "system" fn PropVariantToBSTR(propvar : *const PROPVARIANT, pbstrout : *mut BSTR) -> HRESULT);
+windows_targets::link!("propsys.dll" "system" fn PropVariantToBoolean(propvarin : *const PROPVARIANT, pfret : *mut BOOL) -> HRESULT);
+windows_targets::link!("propsys.dll" "system" fn PropVariantToDouble(propvarin : *const PROPVARIANT, pdblret : *mut f64) -> HRESULT);
+windows_targets::link!("propsys.dll" "system" fn PropVariantToInt16(propvarin : *const PROPVARIANT, piret : *mut i16) -> HRESULT);
+windows_targets::link!("propsys.dll" "system" fn PropVariantToInt32(propvarin : *const PROPVARIANT, plret : *mut i32) -> HRESULT);
+windows_targets::link!("propsys.dll" "system" fn PropVariantToInt64(propvarin : *const PROPVARIANT, pllret : *mut i64) -> HRESULT);
+windows_targets::link!("propsys.dll" "system" fn PropVariantToUInt16(propvarin : *const PROPVARIANT, puiret : *mut u16) -> HRESULT);
+windows_targets::link!("propsys.dll" "system" fn PropVariantToUInt32(propvarin : *const PROPVARIANT, pulret : *mut u32) -> HRESULT);
+windows_targets::link!("propsys.dll" "system" fn PropVariantToUInt64(propvarin : *const PROPVARIANT, pullret : *mut u64) -> HRESULT);
+windows_targets::link!("propsys.dll" "system" fn PropVariantToVariant(ppropvar : *const PROPVARIANT, pvar : *mut VARIANT) -> HRESULT);
+windows_targets::link!("propsys.dll" "system" fn VariantToBoolean(varin : *const VARIANT, pfret : *mut BOOL) -> HRESULT);
+windows_targets::link!("propsys.dll" "system" fn VariantToDouble(varin : *const VARIANT, pdblret : *mut f64) -> HRESULT);
+windows_targets::link!("propsys.dll" "system" fn VariantToInt16(varin : *const VARIANT, piret : *mut i16) -> HRESULT);
+windows_targets::link!("propsys.dll" "system" fn VariantToInt32(varin : *const VARIANT, plret : *mut i32) -> HRESULT);
+windows_targets::link!("propsys.dll" "system" fn VariantToInt64(varin : *const VARIANT, pllret : *mut i64) -> HRESULT);
+windows_targets::link!("propsys.dll" "system" fn VariantToPropVariant(pvar : *const VARIANT, ppropvar : *mut PROPVARIANT) -> HRESULT);
+windows_targets::link!("propsys.dll" "system" fn VariantToUInt16(varin : *const VARIANT, puiret : *mut u16) -> HRESULT);
+windows_targets::link!("propsys.dll" "system" fn VariantToUInt32(varin : *const VARIANT, pulret : *mut u32) -> HRESULT);
+windows_targets::link!("propsys.dll" "system" fn VariantToUInt64(varin : *const VARIANT, pullret : *mut u64) -> HRESULT);
+pub type ADVANCED_FEATURE_FLAGS = u16;
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct ARRAYDESC {
+    pub tdescElem: TYPEDESC,
+    pub cDims: u16,
+    pub rgbounds: [SAFEARRAYBOUND; 1],
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub union BINDPTR {
+    pub lpfuncdesc: *mut FUNCDESC,
+    pub lpvardesc: *mut VARDESC,
+    pub lptcomp: *mut core::ffi::c_void,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct BLOB {
+    pub cbSize: u32,
+    pub pBlobData: *mut u8,
+}
+pub type BOOL = i32;
+pub type BSTR = *const u16;
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct BSTRBLOB {
+    pub cbSize: u32,
+    pub pData: *mut u8,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct CABOOL {
+    pub cElems: u32,
+    pub pElems: *mut VARIANT_BOOL,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct CABSTR {
+    pub cElems: u32,
+    pub pElems: *mut BSTR,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct CABSTRBLOB {
+    pub cElems: u32,
+    pub pElems: *mut BSTRBLOB,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct CAC {
+    pub cElems: u32,
+    pub pElems: PSTR,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct CACLIPDATA {
+    pub cElems: u32,
+    pub pElems: *mut CLIPDATA,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct CACLSID {
+    pub cElems: u32,
+    pub pElems: *mut GUID,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct CACY {
+    pub cElems: u32,
+    pub pElems: *mut CY,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct CADATE {
+    pub cElems: u32,
+    pub pElems: *mut f64,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct CADBL {
+    pub cElems: u32,
+    pub pElems: *mut f64,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct CAFILETIME {
+    pub cElems: u32,
+    pub pElems: *mut FILETIME,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct CAFLT {
+    pub cElems: u32,
+    pub pElems: *mut f32,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct CAH {
+    pub cElems: u32,
+    pub pElems: *mut i64,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct CAI {
+    pub cElems: u32,
+    pub pElems: *mut i16,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct CAL {
+    pub cElems: u32,
+    pub pElems: *mut i32,
+}
+pub type CALLCONV = i32;
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct CALPSTR {
+    pub cElems: u32,
+    pub pElems: *mut PSTR,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct CALPWSTR {
+    pub cElems: u32,
+    pub pElems: *mut PWSTR,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct CAPROPVARIANT {
+    pub cElems: u32,
+    pub pElems: *mut PROPVARIANT,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct CASCODE {
+    pub cElems: u32,
+    pub pElems: *mut i32,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct CAUB {
+    pub cElems: u32,
+    pub pElems: *mut u8,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct CAUH {
+    pub cElems: u32,
+    pub pElems: *mut u64,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct CAUI {
+    pub cElems: u32,
+    pub pElems: *mut u16,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct CAUL {
+    pub cElems: u32,
+    pub pElems: *mut u32,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct CLIPDATA {
+    pub cbSize: u32,
+    pub ulClipFmt: i32,
+    pub pClipData: *mut u8,
+}
+pub type CO_MTA_USAGE_COOKIE = *mut core::ffi::c_void;
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub union CY {
+    pub Anonymous: CY_0,
+    pub int64: i64,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct CY_0 {
+    pub Lo: u32,
+    pub Hi: i32,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct DECIMAL {
+    pub wReserved: u16,
+    pub Anonymous1: DECIMAL_0,
+    pub Hi32: u32,
+    pub Anonymous2: DECIMAL_1,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub union DECIMAL_0 {
+    pub Anonymous: DECIMAL_0_0,
+    pub signscale: u16,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct DECIMAL_0_0 {
+    pub scale: u8,
+    pub sign: u8,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub union DECIMAL_1 {
+    pub Anonymous: DECIMAL_1_0,
+    pub Lo64: u64,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct DECIMAL_1_0 {
+    pub Lo32: u32,
+    pub Mid32: u32,
+}
+pub type DESCKIND = i32;
+pub type DISPATCH_FLAGS = u16;
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct DISPPARAMS {
+    pub rgvarg: *mut VARIANT,
+    pub rgdispidNamedArgs: *mut i32,
+    pub cArgs: u32,
+    pub cNamedArgs: u32,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct ELEMDESC {
+    pub tdesc: TYPEDESC,
+    pub Anonymous: ELEMDESC_0,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub union ELEMDESC_0 {
+    pub idldesc: IDLDESC,
+    pub paramdesc: PARAMDESC,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct EXCEPINFO {
+    pub wCode: u16,
+    pub wReserved: u16,
+    pub bstrSource: BSTR,
+    pub bstrDescription: BSTR,
+    pub bstrHelpFile: BSTR,
+    pub dwHelpContext: u32,
+    pub pvReserved: *mut core::ffi::c_void,
+    pub pfnDeferredFillIn: LPEXCEPFINO_DEFERRED_FILLIN,
+    pub scode: i32,
+}
+pub type FARPROC = Option<unsafe extern "system" fn() -> isize>;
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct FILETIME {
+    pub dwLowDateTime: u32,
+    pub dwHighDateTime: u32,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct FUNCDESC {
+    pub memid: i32,
+    pub lprgscode: *mut i32,
+    pub lprgelemdescParam: *mut ELEMDESC,
+    pub funckind: FUNCKIND,
+    pub invkind: INVOKEKIND,
+    pub callconv: CALLCONV,
+    pub cParams: i16,
+    pub cParamsOpt: i16,
+    pub oVft: i16,
+    pub cScodes: i16,
+    pub elemdescFunc: ELEMDESC,
+    pub wFuncFlags: FUNCFLAGS,
+}
+pub type FUNCFLAGS = u16;
+pub type FUNCKIND = i32;
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct GUID {
+    pub data1: u32,
+    pub data2: u16,
+    pub data3: u16,
+    pub data4: [u8; 8],
+}
+impl GUID {
+    pub const fn from_u128(uuid: u128) -> Self {
+        Self {
+            data1: (uuid >> 96) as u32,
+            data2: (uuid >> 80 & 0xffff) as u16,
+            data3: (uuid >> 64 & 0xffff) as u16,
+            data4: (uuid as u64).to_be_bytes(),
+        }
+    }
+}
+pub type HANDLE = *mut core::ffi::c_void;
+pub type HMODULE = *mut core::ffi::c_void;
+pub type HRESULT = i32;
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct IDLDESC {
+    pub dwReserved: usize,
+    pub wIDLFlags: IDLFLAGS,
+}
+pub type IDLFLAGS = u16;
+pub type IMPLTYPEFLAGS = i32;
+pub type INVOKEKIND = i32;
+pub type LOAD_LIBRARY_FLAGS = u32;
+pub const LOAD_LIBRARY_SEARCH_DEFAULT_DIRS: LOAD_LIBRARY_FLAGS = 4096u32;
+pub type LPEXCEPFINO_DEFERRED_FILLIN =
+    Option<unsafe extern "system" fn(pexcepinfo: *mut EXCEPINFO) -> HRESULT>;
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct PARAMDESC {
+    pub pparamdescex: *mut PARAMDESCEX,
+    pub wParamFlags: PARAMFLAGS,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct PARAMDESCEX {
+    pub cBytes: u32,
+    pub varDefaultValue: VARIANT,
+}
+pub type PARAMFLAGS = u16;
+pub type PCSTR = *const u8;
+pub type PCWSTR = *const u16;
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct PROPVARIANT {
+    pub Anonymous: PROPVARIANT_0,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub union PROPVARIANT_0 {
+    pub Anonymous: PROPVARIANT_0_0,
+    pub decVal: DECIMAL,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct PROPVARIANT_0_0 {
+    pub vt: VARENUM,
+    pub wReserved1: u16,
+    pub wReserved2: u16,
+    pub wReserved3: u16,
+    pub Anonymous: PROPVARIANT_0_0_0,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub union PROPVARIANT_0_0_0 {
+    pub cVal: i8,
+    pub bVal: u8,
+    pub iVal: i16,
+    pub uiVal: u16,
+    pub lVal: i32,
+    pub ulVal: u32,
+    pub intVal: i32,
+    pub uintVal: u32,
+    pub hVal: i64,
+    pub uhVal: u64,
+    pub fltVal: f32,
+    pub dblVal: f64,
+    pub boolVal: VARIANT_BOOL,
+    pub __OBSOLETE__VARIANT_BOOL: VARIANT_BOOL,
+    pub scode: i32,
+    pub cyVal: CY,
+    pub date: f64,
+    pub filetime: FILETIME,
+    pub puuid: *mut GUID,
+    pub pclipdata: *mut CLIPDATA,
+    pub bstrVal: BSTR,
+    pub bstrblobVal: BSTRBLOB,
+    pub blob: BLOB,
+    pub pszVal: PSTR,
+    pub pwszVal: PWSTR,
+    pub punkVal: *mut core::ffi::c_void,
+    pub pdispVal: *mut core::ffi::c_void,
+    pub pStream: *mut core::ffi::c_void,
+    pub pStorage: *mut core::ffi::c_void,
+    pub pVersionedStream: *mut VERSIONEDSTREAM,
+    pub parray: *mut SAFEARRAY,
+    pub cac: CAC,
+    pub caub: CAUB,
+    pub cai: CAI,
+    pub caui: CAUI,
+    pub cal: CAL,
+    pub caul: CAUL,
+    pub cah: CAH,
+    pub cauh: CAUH,
+    pub caflt: CAFLT,
+    pub cadbl: CADBL,
+    pub cabool: CABOOL,
+    pub cascode: CASCODE,
+    pub cacy: CACY,
+    pub cadate: CADATE,
+    pub cafiletime: CAFILETIME,
+    pub cauuid: CACLSID,
+    pub caclipdata: CACLIPDATA,
+    pub cabstr: CABSTR,
+    pub cabstrblob: CABSTRBLOB,
+    pub calpstr: CALPSTR,
+    pub calpwstr: CALPWSTR,
+    pub capropvar: CAPROPVARIANT,
+    pub pcVal: PSTR,
+    pub pbVal: *mut u8,
+    pub piVal: *mut i16,
+    pub puiVal: *mut u16,
+    pub plVal: *mut i32,
+    pub pulVal: *mut u32,
+    pub pintVal: *mut i32,
+    pub puintVal: *mut u32,
+    pub pfltVal: *mut f32,
+    pub pdblVal: *mut f64,
+    pub pboolVal: *mut VARIANT_BOOL,
+    pub pdecVal: *mut DECIMAL,
+    pub pscode: *mut i32,
+    pub pcyVal: *mut CY,
+    pub pdate: *mut f64,
+    pub pbstrVal: *mut BSTR,
+    pub ppunkVal: *mut *mut core::ffi::c_void,
+    pub ppdispVal: *mut *mut core::ffi::c_void,
+    pub pparray: *mut *mut SAFEARRAY,
+    pub pvarVal: *mut PROPVARIANT,
+}
+pub type PROPVAR_COMPARE_FLAGS = i32;
+pub type PROPVAR_COMPARE_UNIT = i32;
+pub type PSTR = *mut u8;
+pub type PWSTR = *mut u16;
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct SAFEARRAY {
+    pub cDims: u16,
+    pub fFeatures: ADVANCED_FEATURE_FLAGS,
+    pub cbElements: u32,
+    pub cLocks: u32,
+    pub pvData: *mut core::ffi::c_void,
+    pub rgsabound: [SAFEARRAYBOUND; 1],
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct SAFEARRAYBOUND {
+    pub cElements: u32,
+    pub lLbound: i32,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct SECURITY_ATTRIBUTES {
+    pub nLength: u32,
+    pub lpSecurityDescriptor: *mut core::ffi::c_void,
+    pub bInheritHandle: BOOL,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct STATSTG {
+    pub pwcsName: PWSTR,
+    pub r#type: u32,
+    pub cbSize: u64,
+    pub mtime: FILETIME,
+    pub ctime: FILETIME,
+    pub atime: FILETIME,
+    pub grfMode: STGM,
+    pub grfLocksSupported: u32,
+    pub clsid: GUID,
+    pub grfStateBits: u32,
+    pub reserved: u32,
+}
+pub type STGM = u32;
+pub type STREAM_SEEK = u32;
+pub type SYSKIND = i32;
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct TLIBATTR {
+    pub guid: GUID,
+    pub lcid: u32,
+    pub syskind: SYSKIND,
+    pub wMajorVerNum: u16,
+    pub wMinorVerNum: u16,
+    pub wLibFlags: u16,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct TYPEATTR {
+    pub guid: GUID,
+    pub lcid: u32,
+    pub dwReserved: u32,
+    pub memidConstructor: i32,
+    pub memidDestructor: i32,
+    pub lpstrSchema: PWSTR,
+    pub cbSizeInstance: u32,
+    pub typekind: TYPEKIND,
+    pub cFuncs: u16,
+    pub cVars: u16,
+    pub cImplTypes: u16,
+    pub cbSizeVft: u16,
+    pub cbAlignment: u16,
+    pub wTypeFlags: u16,
+    pub wMajorVerNum: u16,
+    pub wMinorVerNum: u16,
+    pub tdescAlias: TYPEDESC,
+    pub idldescType: IDLDESC,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct TYPEDESC {
+    pub Anonymous: TYPEDESC_0,
+    pub vt: VARENUM,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub union TYPEDESC_0 {
+    pub lptdesc: *mut TYPEDESC,
+    pub lpadesc: *mut ARRAYDESC,
+    pub hreftype: u32,
+}
+pub type TYPEKIND = i32;
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct VARDESC {
+    pub memid: i32,
+    pub lpstrSchema: PWSTR,
+    pub Anonymous: VARDESC_0,
+    pub elemdescVar: ELEMDESC,
+    pub wVarFlags: VARFLAGS,
+    pub varkind: VARKIND,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub union VARDESC_0 {
+    pub oInst: u32,
+    pub lpvarValue: *mut VARIANT,
+}
+pub type VARENUM = u16;
+pub type VARFLAGS = u16;
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct VARIANT {
+    pub Anonymous: VARIANT_0,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub union VARIANT_0 {
+    pub Anonymous: VARIANT_0_0,
+    pub decVal: DECIMAL,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct VARIANT_0_0 {
+    pub vt: VARENUM,
+    pub wReserved1: u16,
+    pub wReserved2: u16,
+    pub wReserved3: u16,
+    pub Anonymous: VARIANT_0_0_0,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub union VARIANT_0_0_0 {
+    pub llVal: i64,
+    pub lVal: i32,
+    pub bVal: u8,
+    pub iVal: i16,
+    pub fltVal: f32,
+    pub dblVal: f64,
+    pub boolVal: VARIANT_BOOL,
+    pub __OBSOLETE__VARIANT_BOOL: VARIANT_BOOL,
+    pub scode: i32,
+    pub cyVal: CY,
+    pub date: f64,
+    pub bstrVal: BSTR,
+    pub punkVal: *mut core::ffi::c_void,
+    pub pdispVal: *mut core::ffi::c_void,
+    pub parray: *mut SAFEARRAY,
+    pub pbVal: *mut u8,
+    pub piVal: *mut i16,
+    pub plVal: *mut i32,
+    pub pllVal: *mut i64,
+    pub pfltVal: *mut f32,
+    pub pdblVal: *mut f64,
+    pub pboolVal: *mut VARIANT_BOOL,
+    pub __OBSOLETE__VARIANT_PBOOL: *mut VARIANT_BOOL,
+    pub pscode: *mut i32,
+    pub pcyVal: *mut CY,
+    pub pdate: *mut f64,
+    pub pbstrVal: *mut BSTR,
+    pub ppunkVal: *mut *mut core::ffi::c_void,
+    pub ppdispVal: *mut *mut core::ffi::c_void,
+    pub pparray: *mut *mut SAFEARRAY,
+    pub pvarVal: *mut VARIANT,
+    pub byref: *mut core::ffi::c_void,
+    pub cVal: i8,
+    pub uiVal: u16,
+    pub ulVal: u32,
+    pub ullVal: u64,
+    pub intVal: i32,
+    pub uintVal: u32,
+    pub pdecVal: *mut DECIMAL,
+    pub pcVal: PSTR,
+    pub puiVal: *mut u16,
+    pub pulVal: *mut u32,
+    pub pullVal: *mut u64,
+    pub pintVal: *mut i32,
+    pub puintVal: *mut u32,
+    pub Anonymous: VARIANT_0_0_0_0,
+}
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct VARIANT_0_0_0_0 {
+    pub pvRecord: *mut core::ffi::c_void,
+    pub pRecInfo: *mut core::ffi::c_void,
+}
+pub type VARIANT_BOOL = i16;
+pub type VARKIND = i32;
+#[repr(C)]
+#[derive(Clone, Copy)]
+pub struct VERSIONEDSTREAM {
+    pub guidVersion: GUID,
+    pub pStream: *mut core::ffi::c_void,
+}
+pub const VT_BOOL: VARENUM = 11u16;
+pub const VT_BSTR: VARENUM = 8u16;
+pub const VT_EMPTY: VARENUM = 0u16;
+pub const VT_I1: VARENUM = 16u16;
+pub const VT_I2: VARENUM = 2u16;
+pub const VT_I4: VARENUM = 3u16;
+pub const VT_I8: VARENUM = 20u16;
+pub const VT_R4: VARENUM = 4u16;
+pub const VT_R8: VARENUM = 5u16;
+pub const VT_UI1: VARENUM = 17u16;
+pub const VT_UI2: VARENUM = 18u16;
+pub const VT_UI4: VARENUM = 19u16;
+pub const VT_UI8: VARENUM = 21u16;
+pub const VT_UNKNOWN: VARENUM = 13u16;
+pub type WAIT_EVENT = u32;

vendor/windows-core-0.58.0/src/imp/can_into.rs

@@ -0,0 +1,5 @@
+pub trait CanInto<T>: Sized {
+    const QUERY: bool = false;
+}
+
+impl<T> CanInto<T> for T where T: Clone {}

vendor/windows-core-0.58.0/src/imp/com_bindings.rs

@@ -0,0 +1,166 @@
+#![allow(
+    non_snake_case,
+    non_upper_case_globals,
+    non_camel_case_types,
+    dead_code,
+    clippy::all
+)]
+#[inline]
+pub unsafe fn CoCreateGuid() -> windows_core::Result<windows_core::GUID> {
+    windows_targets::link!("ole32.dll" "system" fn CoCreateGuid(pguid : *mut windows_core::GUID) -> windows_core::HRESULT);
+    let mut result__ = core::mem::zeroed();
+    CoCreateGuid(&mut result__).map(|| result__)
+}
+#[inline]
+pub unsafe fn RoGetAgileReference<P0>(
+    options: AgileReferenceOptions,
+    riid: *const windows_core::GUID,
+    punk: P0,
+) -> windows_core::Result<IAgileReference>
+where
+    P0: windows_core::Param<windows_core::IUnknown>,
+{
+    windows_targets::link!("ole32.dll" "system" fn RoGetAgileReference(options : AgileReferenceOptions, riid : *const windows_core::GUID, punk : * mut core::ffi::c_void, ppagilereference : *mut * mut core::ffi::c_void) -> windows_core::HRESULT);
+    let mut result__ = core::mem::zeroed();
+    RoGetAgileReference(options, riid, punk.param().abi(), &mut result__)
+        .and_then(|| windows_core::Type::from_abi(result__))
+}
+pub const AGILEREFERENCE_DEFAULT: AgileReferenceOptions = AgileReferenceOptions(0i32);
+#[repr(transparent)]
+#[derive(PartialEq, Eq, Copy, Clone, Default)]
+pub struct AgileReferenceOptions(pub i32);
+impl windows_core::TypeKind for AgileReferenceOptions {
+    type TypeKind = windows_core::CopyType;
+}
+impl core::fmt::Debug for AgileReferenceOptions {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        f.debug_tuple("AgileReferenceOptions")
+            .field(&self.0)
+            .finish()
+    }
+}
+pub const CO_E_NOTINITIALIZED: windows_core::HRESULT = windows_core::HRESULT(0x800401F0_u32 as _);
+pub const E_BOUNDS: windows_core::HRESULT = windows_core::HRESULT(0x8000000B_u32 as _);
+pub const E_NOINTERFACE: windows_core::HRESULT = windows_core::HRESULT(0x80004002_u32 as _);
+pub const E_OUTOFMEMORY: windows_core::HRESULT = windows_core::HRESULT(0x8007000E_u32 as _);
+pub const E_POINTER: windows_core::HRESULT = windows_core::HRESULT(0x80004003_u32 as _);
+windows_core::imp::define_interface!(
+    IAgileObject,
+    IAgileObject_Vtbl,
+    0x94ea2b94_e9cc_49e0_c0ff_ee64ca8f5b90
+);
+impl core::ops::Deref for IAgileObject {
+    type Target = windows_core::IUnknown;
+    fn deref(&self) -> &Self::Target {
+        unsafe { core::mem::transmute(self) }
+    }
+}
+windows_core::imp::interface_hierarchy!(IAgileObject, windows_core::IUnknown);
+impl IAgileObject {}
+#[repr(C)]
+pub struct IAgileObject_Vtbl {
+    pub base__: windows_core::IUnknown_Vtbl,
+}
+windows_core::imp::define_interface!(
+    IAgileReference,
+    IAgileReference_Vtbl,
+    0xc03f6a43_65a4_9818_987e_e0b810d2a6f2
+);
+impl core::ops::Deref for IAgileReference {
+    type Target = windows_core::IUnknown;
+    fn deref(&self) -> &Self::Target {
+        unsafe { core::mem::transmute(self) }
+    }
+}
+windows_core::imp::interface_hierarchy!(IAgileReference, windows_core::IUnknown);
+impl IAgileReference {
+    pub unsafe fn Resolve<T>(&self) -> windows_core::Result<T>
+    where
+        T: windows_core::Interface,
+    {
+        let mut result__ = core::ptr::null_mut();
+        (windows_core::Interface::vtable(self).Resolve)(
+            windows_core::Interface::as_raw(self),
+            &T::IID,
+            &mut result__,
+        )
+        .and_then(|| windows_core::Type::from_abi(result__))
+    }
+}
+#[repr(C)]
+pub struct IAgileReference_Vtbl {
+    pub base__: windows_core::IUnknown_Vtbl,
+    pub Resolve: unsafe extern "system" fn(
+        *mut core::ffi::c_void,
+        *const windows_core::GUID,
+        *mut *mut core::ffi::c_void,
+    ) -> windows_core::HRESULT,
+}
+windows_core::imp::define_interface!(
+    IWeakReference,
+    IWeakReference_Vtbl,
+    0x00000037_0000_0000_c000_000000000046
+);
+impl core::ops::Deref for IWeakReference {
+    type Target = windows_core::IUnknown;
+    fn deref(&self) -> &Self::Target {
+        unsafe { core::mem::transmute(self) }
+    }
+}
+windows_core::imp::interface_hierarchy!(IWeakReference, windows_core::IUnknown);
+impl IWeakReference {
+    pub unsafe fn Resolve<T>(&self) -> windows_core::Result<T>
+    where
+        T: windows_core::Interface,
+    {
+        let mut result__ = core::ptr::null_mut();
+        (windows_core::Interface::vtable(self).Resolve)(
+            windows_core::Interface::as_raw(self),
+            &T::IID,
+            &mut result__,
+        )
+        .and_then(|| windows_core::Type::from_abi(result__))
+    }
+}
+#[repr(C)]
+pub struct IWeakReference_Vtbl {
+    pub base__: windows_core::IUnknown_Vtbl,
+    pub Resolve: unsafe extern "system" fn(
+        *mut core::ffi::c_void,
+        *const windows_core::GUID,
+        *mut *mut core::ffi::c_void,
+    ) -> windows_core::HRESULT,
+}
+windows_core::imp::define_interface!(
+    IWeakReferenceSource,
+    IWeakReferenceSource_Vtbl,
+    0x00000038_0000_0000_c000_000000000046
+);
+impl core::ops::Deref for IWeakReferenceSource {
+    type Target = windows_core::IUnknown;
+    fn deref(&self) -> &Self::Target {
+        unsafe { core::mem::transmute(self) }
+    }
+}
+windows_core::imp::interface_hierarchy!(IWeakReferenceSource, windows_core::IUnknown);
+impl IWeakReferenceSource {
+    pub unsafe fn GetWeakReference(&self) -> windows_core::Result<IWeakReference> {
+        let mut result__ = core::mem::zeroed();
+        (windows_core::Interface::vtable(self).GetWeakReference)(
+            windows_core::Interface::as_raw(self),
+            &mut result__,
+        )
+        .and_then(|| windows_core::Type::from_abi(result__))
+    }
+}
+#[repr(C)]
+pub struct IWeakReferenceSource_Vtbl {
+    pub base__: windows_core::IUnknown_Vtbl,
+    pub GetWeakReference: unsafe extern "system" fn(
+        *mut core::ffi::c_void,
+        *mut *mut core::ffi::c_void,
+    ) -> windows_core::HRESULT,
+}
+pub const JSCRIPT_E_CANTEXECUTE: windows_core::HRESULT = windows_core::HRESULT(0x89020001_u32 as _);
+pub const RPC_E_DISCONNECTED: windows_core::HRESULT = windows_core::HRESULT(0x80010108_u32 as _);
+pub const TYPE_E_TYPEMISMATCH: windows_core::HRESULT = windows_core::HRESULT(0x80028CA0_u32 as _);

vendor/windows-core-0.58.0/src/imp/factory_cache.rs

@@ -0,0 +1,210 @@
+use super::*;
+use crate::Interface;
+use core::ffi::c_void;
+use core::marker::PhantomData;
+use core::mem::{forget, transmute, transmute_copy};
+use core::ptr::null_mut;
+use core::sync::atomic::{AtomicPtr, Ordering};
+
+pub struct FactoryCache<C, I> {
+    shared: AtomicPtr<c_void>,
+    _c: PhantomData<C>,
+    _i: PhantomData<I>,
+}
+
+impl<C, I> FactoryCache<C, I> {
+    pub const fn new() -> Self {
+        Self {
+            shared: AtomicPtr::new(null_mut()),
+            _c: PhantomData,
+            _i: PhantomData,
+        }
+    }
+}
+
+impl<C, I> Default for FactoryCache<C, I> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<C: crate::RuntimeName, I: Interface> FactoryCache<C, I> {
+    pub fn call<R, F: FnOnce(&I) -> crate::Result<R>>(&self, callback: F) -> crate::Result<R> {
+        loop {
+            // Attempt to load a previously cached factory pointer.
+            let ptr = self.shared.load(Ordering::Relaxed);
+
+            // If a pointer is found, the cache is primed and we're good to go.
+            if !ptr.is_null() {
+                return callback(unsafe { transmute::<&*mut c_void, &I>(&ptr) });
+            }
+
+            // Otherwise, we load the factory the usual way.
+            let factory = factory::<C, I>()?;
+
+            // If the factory is agile, we can safely cache it.
+            if factory.cast::<IAgileObject>().is_ok() {
+                if self
+                    .shared
+                    .compare_exchange_weak(
+                        null_mut(),
+                        factory.as_raw(),
+                        Ordering::Relaxed,
+                        Ordering::Relaxed,
+                    )
+                    .is_ok()
+                {
+                    forget(factory);
+                }
+            } else {
+                // Otherwise, for non-agile factories we simply use the factory
+                // and discard after use as it is not safe to cache.
+                return callback(&factory);
+            }
+        }
+    }
+}
+
+// This is safe because `FactoryCache` only holds agile factory pointers, which are safe to cache and share between threads.
+unsafe impl<C, I> Sync for FactoryCache<C, I> {}
+
+/// Attempts to load the factory object for the given WinRT class.
+/// This can be used to access COM interfaces implemented on a Windows Runtime class factory.
+pub fn factory<C: crate::RuntimeName, I: Interface>() -> crate::Result<I> {
+    let mut factory: Option<I> = None;
+    let name = crate::HSTRING::from(C::NAME);
+
+    let code = unsafe {
+        let mut get_com_factory = || {
+            crate::HRESULT(RoGetActivationFactory(
+                transmute_copy(&name),
+                &I::IID as *const _ as _,
+                &mut factory as *mut _ as *mut _,
+            ))
+        };
+        let mut code = get_com_factory();
+
+        // If RoGetActivationFactory fails because combase hasn't been loaded yet then load combase
+        // automatically so that it "just works" for apartment-agnostic code.
+        if code == CO_E_NOTINITIALIZED {
+            let mut cookie = core::ptr::null_mut();
+            CoIncrementMTAUsage(&mut cookie);
+
+            // Now try a second time to get the activation factory via the OS.
+            code = get_com_factory();
+        }
+
+        code
+    };
+
+    // If this succeeded then return the resulting factory interface.
+    if let Some(factory) = factory {
+        return Ok(factory);
+    }
+
+    // If not, first capture the error information from the failure above so that we
+    // can ultimately return this error information if all else fails.
+    let original: crate::Error = code.into();
+
+    // Now attempt to find the factory's implementation heuristically.
+    if let Some(i) = search_path(C::NAME, |library| unsafe {
+        get_activation_factory(library, &name)
+    }) {
+        i.cast()
+    } else {
+        Err(original)
+    }
+}
+
+// Remove the suffix until a match is found appending `.dll\0` at the end
+///
+/// For example, if the class name is
+/// "A.B.TypeName" then the attempted load order will be:
+///   1. A.B.dll
+///   2. A.dll
+fn search_path<F, R>(mut path: &str, mut callback: F) -> Option<R>
+where
+    F: FnMut(crate::PCSTR) -> crate::Result<R>,
+{
+    let suffix = b".dll\0";
+    let mut library = alloc::vec![0; path.len() + suffix.len()];
+    while let Some(pos) = path.rfind('.') {
+        path = &path[..pos];
+        library.truncate(path.len() + suffix.len());
+        library[..path.len()].copy_from_slice(path.as_bytes());
+        library[path.len()..].copy_from_slice(suffix);
+
+        if let Ok(r) = callback(crate::PCSTR::from_raw(library.as_ptr())) {
+            return Some(r);
+        }
+    }
+
+    None
+}
+
+unsafe fn get_activation_factory(
+    library: crate::PCSTR,
+    name: &crate::HSTRING,
+) -> crate::Result<IGenericFactory> {
+    let function =
+        delay_load::<DllGetActivationFactory>(library, crate::s!("DllGetActivationFactory"))
+            .ok_or_else(crate::Error::from_win32)?;
+    let mut abi = null_mut();
+    function(transmute_copy(name), &mut abi).and_then(|| crate::Type::from_abi(abi))
+}
+
+unsafe fn delay_load<T>(library: crate::PCSTR, function: crate::PCSTR) -> Option<T> {
+    let library = LoadLibraryExA(
+        library.0,
+        core::ptr::null_mut(),
+        LOAD_LIBRARY_SEARCH_DEFAULT_DIRS,
+    );
+
+    if library.is_null() {
+        return None;
+    }
+
+    let address = GetProcAddress(library, function.0);
+
+    if address.is_some() {
+        return Some(core::mem::transmute_copy(&address));
+    }
+
+    FreeLibrary(library);
+    None
+}
+
+type DllGetActivationFactory =
+    extern "system" fn(name: *mut c_void, factory: *mut *mut c_void) -> crate::HRESULT;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn dll_search() {
+        let path = "A.B.TypeName";
+
+        // Test library successfully found
+        let mut results = Vec::new();
+        let end_result = search_path(path, |library| {
+            results.push(unsafe { library.to_string().unwrap() });
+            if unsafe { library.as_bytes() } == &b"A.dll"[..] {
+                Ok(42)
+            } else {
+                Err(crate::Error::empty())
+            }
+        });
+        assert!(matches!(end_result, Some(42)));
+        assert_eq!(results, vec!["A.B.dll", "A.dll"]);
+
+        // Test library never successfully found
+        let mut results = Vec::new();
+        let end_result = search_path(path, |library| {
+            results.push(unsafe { library.to_string().unwrap() });
+            crate::Result::<()>::Err(crate::Error::empty())
+        });
+        assert!(end_result.is_none());
+        assert_eq!(results, vec!["A.B.dll", "A.dll"]);
+    }
+}

vendor/windows-core-0.58.0/src/imp/generic_factory.rs

@@ -0,0 +1,33 @@
+use crate::Interface;
+use core::ffi::c_void;
+use core::mem::{transmute_copy, zeroed};
+
+// A streamlined version of the IActivationFactory interface used by WinRT class factories used internally by the windows crate
+// to simplify code generation. Components should implement the `IActivationFactory` interface published by the windows crate.
+super::define_interface!(
+    IGenericFactory,
+    IGenericFactory_Vtbl,
+    0x00000035_0000_0000_c000_000000000046
+);
+super::interface_hierarchy!(IGenericFactory, crate::IUnknown, crate::IInspectable);
+
+impl IGenericFactory {
+    pub fn ActivateInstance<I: Interface>(&self) -> crate::Result<I> {
+        unsafe {
+            let mut result__ = zeroed();
+            (Interface::vtable(self).ActivateInstance)(
+                transmute_copy(self),
+                &mut result__ as *mut _ as *mut _,
+            )
+            .and_then(|| crate::Type::from_abi(result__))
+            .and_then(|interface: crate::IInspectable| interface.cast())
+        }
+    }
+}
+
+#[repr(C)]
+pub struct IGenericFactory_Vtbl {
+    pub base__: crate::IInspectable_Vtbl,
+    pub ActivateInstance:
+        unsafe extern "system" fn(this: *mut c_void, instance: *mut *mut c_void) -> crate::HRESULT,
+}

vendor/windows-core-0.58.0/src/imp/mod.rs

@@ -0,0 +1,96 @@
+#[cfg(windows)]
+include!("windows.rs");
+
+mod can_into;
+mod com_bindings;
+mod ref_count;
+mod sha1;
+mod weak_ref_count;
+
+pub use can_into::*;
+pub use com_bindings::*;
+pub use ref_count::*;
+pub use sha1::*;
+pub use weak_ref_count::*;
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! interface_hierarchy {
+    ($child:ident, $parent:ty) => {
+        impl ::windows_core::imp::CanInto<$parent> for $child {}
+        impl ::core::convert::From<&$child> for &$parent {
+            fn from(value: &$child) -> Self {
+                unsafe { ::core::mem::transmute(value) }
+            }
+        }
+        impl ::core::convert::From<$child> for $parent {
+            fn from(value: $child) -> Self {
+                unsafe { ::core::mem::transmute(value) }
+            }
+        }
+    };
+    ($child:ident, $first:ty, $($rest:ty),+) => {
+        $crate::imp::interface_hierarchy!($child, $first);
+        $crate::imp::interface_hierarchy!($child, $($rest),+);
+    };
+}
+
+#[doc(hidden)]
+pub use interface_hierarchy;
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! required_hierarchy {
+    ($child:ident, $parent:ty) => {
+        impl ::windows_core::imp::CanInto<$parent> for $child { const QUERY: bool = true; }
+    };
+    ($child:ident, $first:ty, $($rest:ty),+) => {
+        $crate::imp::required_hierarchy!($child, $first);
+        $crate::imp::required_hierarchy!($child, $($rest),+);
+    };
+}
+
+#[doc(hidden)]
+pub use required_hierarchy;
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! define_interface {
+    ($name:ident, $vtbl:ident, $iid:literal) => {
+        #[repr(transparent)]
+        #[derive(::core::cmp::PartialEq, ::core::cmp::Eq, ::core::clone::Clone)]
+        pub struct $name(::windows_core::IUnknown);
+        unsafe impl ::windows_core::Interface for $name {
+            type Vtable = $vtbl;
+            const IID: ::windows_core::GUID = ::windows_core::GUID::from_u128($iid);
+        }
+        impl ::core::fmt::Debug for $name {
+            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> core::fmt::Result {
+                f.debug_tuple(stringify!($name))
+                    .field(&::windows_core::Interface::as_raw(self))
+                    .finish()
+            }
+        }
+    };
+    ($name:ident, $vtbl:ident) => {
+        #[repr(transparent)]
+        #[derive(::core::cmp::PartialEq, ::core::cmp::Eq, ::core::clone::Clone)]
+        pub struct $name(::std::ptr::NonNull<::std::ffi::c_void>);
+        unsafe impl ::windows_core::Interface for $name {
+            type Vtable = $vtbl;
+            const IID: ::windows_core::GUID = ::windows_core::GUID::zeroed();
+            const UNKNOWN: bool = false;
+        }
+        impl ::core::fmt::Debug for $name {
+            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> core::fmt::Result {
+                f.debug_tuple(stringify!($name)).field(&self.0).finish()
+            }
+        }
+    };
+}
+
+#[doc(hidden)]
+pub use define_interface;
+
+#[doc(hidden)]
+pub use alloc::boxed::Box;

vendor/windows-core-0.58.0/src/imp/ref_count.rs

@@ -0,0 +1,33 @@
+use core::sync::atomic::{fence, AtomicI32, Ordering};
+
+#[repr(transparent)]
+#[derive(Default)]
+pub struct RefCount(pub(crate) AtomicI32);
+
+impl RefCount {
+    /// Creates a new `RefCount` with an initial value of `1`.
+    pub fn new(count: u32) -> Self {
+        Self(AtomicI32::new(count as i32))
+    }
+
+    /// Increments the reference count, returning the new value.
+    pub fn add_ref(&self) -> u32 {
+        (self.0.fetch_add(1, Ordering::Relaxed) + 1) as u32
+    }
+
+    /// Decrements the reference count, returning the new value.
+    ///
+    /// This operation inserts an `Acquire` fence when the reference count reaches zero.
+    /// This prevents reordering before the object is destroyed.
+    pub fn release(&self) -> u32 {
+        let remaining = self.0.fetch_sub(1, Ordering::Release) - 1;
+
+        match remaining.cmp(&0) {
+            core::cmp::Ordering::Equal => fence(Ordering::Acquire),
+            core::cmp::Ordering::Less => panic!("Object has been over-released."),
+            core::cmp::Ordering::Greater => {}
+        }
+
+        remaining as u32
+    }
+}

vendor/windows-core-0.58.0/src/imp/sha1.rs

@@ -0,0 +1,483 @@
+#![allow(clippy::many_single_char_names)]
+
+pub const fn sha1(data: &ConstBuffer) -> Digest {
+    let state: [u32; 5] = [0x67452301, 0xefcdab89, 0x98badcfe, 0x10325476, 0xc3d2e1f0];
+    let len: u64 = 0;
+    let blocks = Blocks {
+        len: 0,
+        data: [0; 64],
+    };
+    let (blocks, len, state) = process_blocks(blocks, data, len, state);
+    digest(state, len, blocks)
+}
+
+const BUFFER_SIZE: usize = 1024;
+
+pub struct ConstBuffer {
+    data: [u8; BUFFER_SIZE],
+    head: usize,
+}
+
+impl ConstBuffer {
+    pub const fn for_class<C: crate::RuntimeName, I: crate::RuntimeType>() -> Self {
+        Self::new()
+            .push_slice(b"rc(")
+            .push_slice(C::NAME.as_bytes())
+            .push(b';')
+            .push_other(I::SIGNATURE)
+            .push(b')')
+    }
+
+    pub const fn for_interface<T: crate::Interface>() -> Self {
+        Self::new().push_guid(&T::IID)
+    }
+
+    pub const fn from_slice(slice: &[u8]) -> Self {
+        let s = Self::new();
+        s.push_slice(slice)
+    }
+
+    pub const fn new() -> Self {
+        Self {
+            data: [0; BUFFER_SIZE],
+            head: 0,
+        }
+    }
+
+    pub const fn push_slice(self, slice: &[u8]) -> Self {
+        self.push_amount(slice, slice.len())
+    }
+
+    const fn get(&self, index: usize) -> u8 {
+        self.data[index]
+    }
+
+    const fn len(&self) -> usize {
+        self.head
+    }
+
+    pub fn as_slice(&self) -> &[u8] {
+        &self.data[..self.head]
+    }
+
+    pub const fn push_other(self, other: Self) -> Self {
+        self.push_amount(&other.data, other.len())
+    }
+
+    const fn push(mut self, value: u8) -> Self {
+        self.data[self.head] = value;
+        self.head += 1;
+        self
+    }
+
+    const fn push_hex_u8(self, value: u8) -> Self {
+        const fn digit(mut value: u8) -> u8 {
+            value &= 0xF;
+
+            if value < 10 {
+                b'0' + value
+            } else {
+                b'a' + (value - 10)
+            }
+        }
+
+        self.push(digit(value >> 4)).push(digit(value))
+    }
+
+    const fn push_hex_u16(self, value: u16) -> Self {
+        self.push_hex_u8((value >> 8) as u8)
+            .push_hex_u8((value & 0xFF) as u8)
+    }
+
+    const fn push_hex_u32(self, value: u32) -> Self {
+        self.push_hex_u16((value >> 16) as u16)
+            .push_hex_u16((value & 0xFFFF) as u16)
+    }
+
+    const fn push_amount(mut self, slice: &[u8], amount: usize) -> Self {
+        let mut i = 0;
+        while i < amount {
+            self.data[self.head + i] = slice[i];
+            i += 1;
+        }
+        self.head += i;
+        self
+    }
+
+    const fn push_guid(self, guid: &crate::GUID) -> Self {
+        self.push(b'{')
+            .push_hex_u32(guid.data1)
+            .push(b'-')
+            .push_hex_u16(guid.data2)
+            .push(b'-')
+            .push_hex_u16(guid.data3)
+            .push(b'-')
+            .push_hex_u16((guid.data4[0] as u16) << 8 | guid.data4[1] as u16)
+            .push(b'-')
+            .push_hex_u16((guid.data4[2] as u16) << 8 | guid.data4[3] as u16)
+            .push_hex_u16((guid.data4[4] as u16) << 8 | guid.data4[5] as u16)
+            .push_hex_u16((guid.data4[6] as u16) << 8 | guid.data4[7] as u16)
+            .push(b'}')
+    }
+}
+
+struct Blocks {
+    len: u32,
+    data: [u8; 64],
+}
+
+const fn process_blocks(
+    mut blocks: Blocks,
+    data: &ConstBuffer,
+    mut len: u64,
+    mut state: [u32; 5],
+) -> (Blocks, u64, [u32; 5]) {
+    const fn as_block(input: &ConstBuffer, offset: usize) -> [u32; 16] {
+        let mut result = [0u32; 16];
+
+        let mut i = 0;
+        while i != 16 {
+            let off = offset + (i * 4);
+            result[i] = (input.get(off + 3) as u32)
+                | ((input.get(off + 2) as u32) << 8)
+                | ((input.get(off + 1) as u32) << 16)
+                | ((input.get(off) as u32) << 24);
+            i += 1;
+        }
+        result
+    }
+
+    const fn clone_from_slice_64(
+        mut data: [u8; 64],
+        slice: &[u8],
+        offset: usize,
+        num_elems: usize,
+    ) -> [u8; 64] {
+        let mut i = 0;
+        while i < num_elems {
+            data[i] = slice[offset + i];
+            i += 1;
+        }
+        data
+    }
+
+    let mut i = 0;
+    while i < data.len() {
+        if data.len() - i >= 64 {
+            let chunk_block = as_block(data, i);
+            len += 64;
+            state = process_state(state, chunk_block);
+            i += 64;
+        } else {
+            let num_elems = data.len() - i;
+            blocks.data = clone_from_slice_64(blocks.data, &data.data, i, num_elems);
+            blocks.len = num_elems as u32;
+            break;
+        }
+    }
+    (blocks, len, state)
+}
+
+const fn process_state(mut state: [u32; 5], block: [u32; 16]) -> [u32; 5] {
+    let a = state[0];
+    let b = state[1];
+    let c = state[2];
+    let d = state[3];
+    let e = state[4];
+    let (block, b, e) = r0(block, a, b, c, d, e, 0);
+    let (block, a, d) = r0(block, e, a, b, c, d, 1);
+    let (block, e, c) = r0(block, d, e, a, b, c, 2);
+    let (block, d, b) = r0(block, c, d, e, a, b, 3);
+    let (block, c, a) = r0(block, b, c, d, e, a, 4);
+    let (block, b, e) = r0(block, a, b, c, d, e, 5);
+    let (block, a, d) = r0(block, e, a, b, c, d, 6);
+    let (block, e, c) = r0(block, d, e, a, b, c, 7);
+    let (block, d, b) = r0(block, c, d, e, a, b, 8);
+    let (block, c, a) = r0(block, b, c, d, e, a, 9);
+    let (block, b, e) = r0(block, a, b, c, d, e, 10);
+    let (block, a, d) = r0(block, e, a, b, c, d, 11);
+    let (block, e, c) = r0(block, d, e, a, b, c, 12);
+    let (block, d, b) = r0(block, c, d, e, a, b, 13);
+    let (block, c, a) = r0(block, b, c, d, e, a, 14);
+    let (block, b, e) = r0(block, a, b, c, d, e, 15);
+    let (block, a, d) = r1(block, e, a, b, c, d, 0);
+    let (block, e, c) = r1(block, d, e, a, b, c, 1);
+    let (block, d, b) = r1(block, c, d, e, a, b, 2);
+    let (block, c, a) = r1(block, b, c, d, e, a, 3);
+    let (block, b, e) = r2(block, a, b, c, d, e, 4);
+    let (block, a, d) = r2(block, e, a, b, c, d, 5);
+    let (block, e, c) = r2(block, d, e, a, b, c, 6);
+    let (block, d, b) = r2(block, c, d, e, a, b, 7);
+    let (block, c, a) = r2(block, b, c, d, e, a, 8);
+    let (block, b, e) = r2(block, a, b, c, d, e, 9);
+    let (block, a, d) = r2(block, e, a, b, c, d, 10);
+    let (block, e, c) = r2(block, d, e, a, b, c, 11);
+    let (block, d, b) = r2(block, c, d, e, a, b, 12);
+    let (block, c, a) = r2(block, b, c, d, e, a, 13);
+    let (block, b, e) = r2(block, a, b, c, d, e, 14);
+    let (block, a, d) = r2(block, e, a, b, c, d, 15);
+    let (block, e, c) = r2(block, d, e, a, b, c, 0);
+    let (block, d, b) = r2(block, c, d, e, a, b, 1);
+    let (block, c, a) = r2(block, b, c, d, e, a, 2);
+    let (block, b, e) = r2(block, a, b, c, d, e, 3);
+    let (block, a, d) = r2(block, e, a, b, c, d, 4);
+    let (block, e, c) = r2(block, d, e, a, b, c, 5);
+    let (block, d, b) = r2(block, c, d, e, a, b, 6);
+    let (block, c, a) = r2(block, b, c, d, e, a, 7);
+    let (block, b, e) = r3(block, a, b, c, d, e, 8);
+    let (block, a, d) = r3(block, e, a, b, c, d, 9);
+    let (block, e, c) = r3(block, d, e, a, b, c, 10);
+    let (block, d, b) = r3(block, c, d, e, a, b, 11);
+    let (block, c, a) = r3(block, b, c, d, e, a, 12);
+    let (block, b, e) = r3(block, a, b, c, d, e, 13);
+    let (block, a, d) = r3(block, e, a, b, c, d, 14);
+    let (block, e, c) = r3(block, d, e, a, b, c, 15);
+    let (block, d, b) = r3(block, c, d, e, a, b, 0);
+    let (block, c, a) = r3(block, b, c, d, e, a, 1);
+    let (block, b, e) = r3(block, a, b, c, d, e, 2);
+    let (block, a, d) = r3(block, e, a, b, c, d, 3);
+    let (block, e, c) = r3(block, d, e, a, b, c, 4);
+    let (block, d, b) = r3(block, c, d, e, a, b, 5);
+    let (block, c, a) = r3(block, b, c, d, e, a, 6);
+    let (block, b, e) = r3(block, a, b, c, d, e, 7);
+    let (block, a, d) = r3(block, e, a, b, c, d, 8);
+    let (block, e, c) = r3(block, d, e, a, b, c, 9);
+    let (block, d, b) = r3(block, c, d, e, a, b, 10);
+    let (block, c, a) = r3(block, b, c, d, e, a, 11);
+    let (block, b, e) = r4(block, a, b, c, d, e, 12);
+    let (block, a, d) = r4(block, e, a, b, c, d, 13);
+    let (block, e, c) = r4(block, d, e, a, b, c, 14);
+    let (block, d, b) = r4(block, c, d, e, a, b, 15);
+    let (block, c, a) = r4(block, b, c, d, e, a, 0);
+    let (block, b, e) = r4(block, a, b, c, d, e, 1);
+    let (block, a, d) = r4(block, e, a, b, c, d, 2);
+    let (block, e, c) = r4(block, d, e, a, b, c, 3);
+    let (block, d, b) = r4(block, c, d, e, a, b, 4);
+    let (block, c, a) = r4(block, b, c, d, e, a, 5);
+    let (block, b, e) = r4(block, a, b, c, d, e, 6);
+    let (block, a, d) = r4(block, e, a, b, c, d, 7);
+    let (block, e, c) = r4(block, d, e, a, b, c, 8);
+    let (block, d, b) = r4(block, c, d, e, a, b, 9);
+    let (block, c, a) = r4(block, b, c, d, e, a, 10);
+    let (block, b, e) = r4(block, a, b, c, d, e, 11);
+    let (block, a, d) = r4(block, e, a, b, c, d, 12);
+    let (block, e, c) = r4(block, d, e, a, b, c, 13);
+    let (block, d, b) = r4(block, c, d, e, a, b, 14);
+    let (_, c, a) = r4(block, b, c, d, e, a, 15);
+
+    state[0] = state[0].wrapping_add(a);
+    state[1] = state[1].wrapping_add(b);
+    state[2] = state[2].wrapping_add(c);
+    state[3] = state[3].wrapping_add(d);
+    state[4] = state[4].wrapping_add(e);
+    state
+}
+
+const fn digest(mut state: [u32; 5], len: u64, blocks: Blocks) -> Digest {
+    const fn clone_from_slice_128(
+        mut data: [u8; 128],
+        slice: &[u8],
+        offset: usize,
+        num_elems: usize,
+    ) -> [u8; 128] {
+        let mut i = 0;
+        while i < num_elems {
+            data[i] = slice[offset + i];
+            i += 1;
+        }
+        data
+    }
+
+    const fn clone_slice_128(mut data: [u8; 128], slice: &[u8], _offset: usize) -> [u8; 128] {
+        let mut i = 0;
+        while i < slice.len() {
+            data[_offset + i] = slice[i];
+            i += 1;
+        }
+        data
+    }
+
+    const fn as_block(input: &[u8], offset: usize) -> [u32; 16] {
+        let mut result = [0u32; 16];
+
+        let mut i = 0;
+        while i != 16 {
+            let off = offset + (i * 4);
+            result[i] = (input[off + 3] as u32)
+                | ((input[off + 2] as u32) << 8)
+                | ((input[off + 1] as u32) << 16)
+                | ((input[off] as u32) << 24);
+            i += 1;
+        }
+        result
+    }
+
+    let bits = (len + (blocks.len as u64)) * 8;
+    let extra = [
+        (bits >> 56) as u8,
+        (bits >> 48) as u8,
+        (bits >> 40) as u8,
+        (bits >> 32) as u8,
+        (bits >> 24) as u8,
+        (bits >> 16) as u8,
+        (bits >> 8) as u8,
+        bits as u8,
+    ];
+    let mut last = [0; 128];
+    let blocklen = blocks.len as usize;
+    last = clone_from_slice_128(last, &blocks.data, 0, blocklen);
+    last[blocklen] = 0x80;
+
+    if blocklen < 56 {
+        last = clone_slice_128(last, &extra, 56);
+        state = process_state(state, as_block(&last, 0));
+    } else {
+        last = clone_slice_128(last, &extra, 120);
+        state = process_state(state, as_block(&last, 0));
+        state = process_state(state, as_block(&last, 64));
+    }
+    Digest { data: state }
+}
+
+const fn rol(value: u32, bits: usize) -> u32 {
+    (value << bits) | (value >> (32 - bits))
+}
+
+const fn blk(block: &[u32], i: usize) -> u32 {
+    let value = block[(i + 13) & 15] ^ block[(i + 8) & 15] ^ block[(i + 2) & 15] ^ block[i];
+    rol(value, 1)
+}
+
+const fn r0(
+    block: [u32; 16],
+    v: u32,
+    mut w: u32,
+    x: u32,
+    y: u32,
+    mut z: u32,
+    i: usize,
+) -> ([u32; 16], u32, u32) {
+    let n = ((w & (x ^ y)) ^ y)
+        .wrapping_add(block[i])
+        .wrapping_add(0x5a82_7999)
+        .wrapping_add(rol(v, 5));
+    z = z.wrapping_add(n);
+    w = rol(w, 30);
+    (block, w, z)
+}
+
+const fn r1(
+    mut block: [u32; 16],
+    v: u32,
+    mut w: u32,
+    x: u32,
+    y: u32,
+    mut z: u32,
+    i: usize,
+) -> ([u32; 16], u32, u32) {
+    block[i] = blk(&block, i);
+    let n = ((w & (x ^ y)) ^ y)
+        .wrapping_add(block[i])
+        .wrapping_add(0x5a82_7999)
+        .wrapping_add(rol(v, 5));
+    z = z.wrapping_add(n);
+    w = rol(w, 30);
+    (block, w, z)
+}
+
+const fn r2(
+    mut block: [u32; 16],
+    v: u32,
+    mut w: u32,
+    x: u32,
+    y: u32,
+    mut z: u32,
+    i: usize,
+) -> ([u32; 16], u32, u32) {
+    block[i] = blk(&block, i);
+    let n = (w ^ x ^ y)
+        .wrapping_add(block[i])
+        .wrapping_add(0x6ed9_eba1)
+        .wrapping_add(rol(v, 5));
+    z = z.wrapping_add(n);
+    w = rol(w, 30);
+    (block, w, z)
+}
+
+const fn r3(
+    mut block: [u32; 16],
+    v: u32,
+    mut w: u32,
+    x: u32,
+    y: u32,
+    mut z: u32,
+    i: usize,
+) -> ([u32; 16], u32, u32) {
+    block[i] = blk(&block, i);
+    let n = (((w | x) & y) | (w & x))
+        .wrapping_add(block[i])
+        .wrapping_add(0x8f1b_bcdc)
+        .wrapping_add(rol(v, 5));
+    z = z.wrapping_add(n);
+    w = rol(w, 30);
+    (block, w, z)
+}
+
+const fn r4(
+    mut block: [u32; 16],
+    v: u32,
+    mut w: u32,
+    x: u32,
+    y: u32,
+    mut z: u32,
+    i: usize,
+) -> ([u32; 16], u32, u32) {
+    block[i] = blk(&block, i);
+    let n = (w ^ x ^ y)
+        .wrapping_add(block[i])
+        .wrapping_add(0xca62_c1d6)
+        .wrapping_add(rol(v, 5));
+    z = z.wrapping_add(n);
+    w = rol(w, 30);
+    (block, w, z)
+}
+
+pub struct Digest {
+    data: [u32; 5],
+}
+
+impl Digest {
+    pub const fn bytes(&self) -> [u8; 20] {
+        [
+            (self.data[0] >> 24) as u8,
+            (self.data[0] >> 16) as u8,
+            (self.data[0] >> 8) as u8,
+            self.data[0] as u8,
+            (self.data[1] >> 24) as u8,
+            (self.data[1] >> 16) as u8,
+            (self.data[1] >> 8) as u8,
+            self.data[1] as u8,
+            (self.data[2] >> 24) as u8,
+            (self.data[2] >> 16) as u8,
+            (self.data[2] >> 8) as u8,
+            self.data[2] as u8,
+            (self.data[3] >> 24) as u8,
+            (self.data[3] >> 16) as u8,
+            (self.data[3] >> 8) as u8,
+            self.data[3] as u8,
+            (self.data[4] >> 24) as u8,
+            (self.data[4] >> 16) as u8,
+            (self.data[4] >> 8) as u8,
+            self.data[4] as u8,
+        ]
+    }
+}
+
+impl core::fmt::Display for Digest {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        for i in self.data.iter() {
+            write!(f, "{:08x}", i)?;
+        }
+        Ok(())
+    }
+}

vendor/windows-core-0.58.0/src/imp/waiter.rs

@@ -0,0 +1,40 @@
+use super::*;
+
+pub struct Waiter(HANDLE);
+pub struct WaiterSignaler(HANDLE);
+
+unsafe impl Send for WaiterSignaler {}
+
+impl Waiter {
+    pub fn new() -> crate::Result<(Waiter, WaiterSignaler)> {
+        unsafe {
+            let handle = CreateEventW(core::ptr::null(), 1, 0, core::ptr::null());
+            if handle.is_null() {
+                Err(crate::Error::from_win32())
+            } else {
+                Ok((Waiter(handle), WaiterSignaler(handle)))
+            }
+        }
+    }
+}
+
+impl WaiterSignaler {
+    /// # Safety
+    /// Signals the `Waiter`. This is unsafe because the lifetime of `WaiterSignaler` is not tied
+    /// to the lifetime of the `Waiter`. This is not possible in this case because the `Waiter`
+    /// is used to signal a WinRT async completion and the compiler doesn't know that the lifetime
+    /// of the delegate is bounded by the calling function.
+    pub unsafe fn signal(&self) {
+        // https://github.com/microsoft/windows-rs/pull/374#discussion_r535313344
+        SetEvent(self.0);
+    }
+}
+
+impl Drop for Waiter {
+    fn drop(&mut self) {
+        unsafe {
+            WaitForSingleObject(self.0, 0xFFFFFFFF);
+            CloseHandle(self.0);
+        }
+    }
+}

vendor/windows-core-0.58.0/src/imp/weak_ref_count.rs

@@ -0,0 +1,303 @@
+use super::*;
+use crate::Interface;
+use core::ffi::c_void;
+use core::mem::{transmute, transmute_copy};
+use core::ptr::null_mut;
+use core::sync::atomic::{AtomicIsize, Ordering};
+
+#[repr(transparent)]
+#[derive(Default)]
+pub struct WeakRefCount(AtomicIsize);
+
+impl WeakRefCount {
+    pub fn new() -> Self {
+        Self(AtomicIsize::new(1))
+    }
+
+    pub fn add_ref(&self) -> u32 {
+        self.0
+            .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |count_or_pointer| {
+                bool::then_some(!is_weak_ref(count_or_pointer), count_or_pointer + 1)
+            })
+            .map(|u| u as u32 + 1)
+            .unwrap_or_else(|pointer| unsafe { TearOff::decode(pointer).strong_count.add_ref() })
+    }
+
+    #[inline(always)]
+    pub fn is_one(&self) -> bool {
+        self.0.load(Ordering::Acquire) == 1
+    }
+
+    pub fn release(&self) -> u32 {
+        self.0
+            .fetch_update(Ordering::Release, Ordering::Relaxed, |count_or_pointer| {
+                bool::then_some(!is_weak_ref(count_or_pointer), count_or_pointer - 1)
+            })
+            .map(|u| u as u32 - 1)
+            .unwrap_or_else(|pointer| unsafe {
+                let tear_off = TearOff::decode(pointer);
+                let remaining = tear_off.strong_count.release();
+
+                // If this is the last strong reference, we can release the weak reference implied by the strong reference.
+                // There may still be weak references, so the WeakRelease is called to handle such possibilities.
+                if remaining == 0 {
+                    TearOff::WeakRelease(&mut tear_off.weak_vtable as *mut _ as _);
+                }
+
+                remaining
+            })
+    }
+
+    /// # Safety
+    pub unsafe fn query(&self, iid: &crate::GUID, object: *mut c_void) -> *mut c_void {
+        if iid != &IWeakReferenceSource::IID {
+            return null_mut();
+        }
+
+        let mut count_or_pointer = self.0.load(Ordering::Relaxed);
+
+        if is_weak_ref(count_or_pointer) {
+            return TearOff::from_encoding(count_or_pointer);
+        }
+
+        let tear_off = TearOff::new(object, count_or_pointer as u32);
+        let tear_off_ptr: *mut c_void = transmute_copy(&tear_off);
+        let encoding: usize = ((tear_off_ptr as usize) >> 1) | (1 << (usize::BITS - 1));
+
+        loop {
+            match self.0.compare_exchange_weak(
+                count_or_pointer,
+                encoding as isize,
+                Ordering::AcqRel,
+                Ordering::Relaxed,
+            ) {
+                Ok(_) => {
+                    let result: *mut c_void = transmute(tear_off);
+                    TearOff::from_strong_ptr(result).strong_count.add_ref();
+                    return result;
+                }
+                Err(pointer) => count_or_pointer = pointer,
+            }
+
+            if is_weak_ref(count_or_pointer) {
+                return TearOff::from_encoding(count_or_pointer);
+            }
+
+            TearOff::from_strong_ptr(tear_off_ptr)
+                .strong_count
+                .0
+                .store(count_or_pointer as i32, Ordering::SeqCst);
+        }
+    }
+}
+
+fn is_weak_ref(value: isize) -> bool {
+    value < 0
+}
+
+#[repr(C)]
+struct TearOff {
+    strong_vtable: *const IWeakReferenceSource_Vtbl,
+    weak_vtable: *const IWeakReference_Vtbl,
+    object: *mut c_void,
+    strong_count: RefCount,
+    weak_count: RefCount,
+}
+
+impl TearOff {
+    #[allow(clippy::new_ret_no_self)]
+    unsafe fn new(object: *mut c_void, strong_count: u32) -> IWeakReferenceSource {
+        transmute(Box::new(TearOff {
+            strong_vtable: &Self::STRONG_VTABLE,
+            weak_vtable: &Self::WEAK_VTABLE,
+            object,
+            strong_count: RefCount::new(strong_count),
+            weak_count: RefCount::new(1),
+        }))
+    }
+
+    unsafe fn from_encoding(encoding: isize) -> *mut c_void {
+        let tear_off = TearOff::decode(encoding);
+        tear_off.strong_count.add_ref();
+        tear_off as *mut _ as *mut _
+    }
+
+    const STRONG_VTABLE: IWeakReferenceSource_Vtbl = IWeakReferenceSource_Vtbl {
+        base__: crate::IUnknown_Vtbl {
+            QueryInterface: Self::StrongQueryInterface,
+            AddRef: Self::StrongAddRef,
+            Release: Self::StrongRelease,
+        },
+        GetWeakReference: Self::StrongDowngrade,
+    };
+
+    const WEAK_VTABLE: IWeakReference_Vtbl = IWeakReference_Vtbl {
+        base__: crate::IUnknown_Vtbl {
+            QueryInterface: Self::WeakQueryInterface,
+            AddRef: Self::WeakAddRef,
+            Release: Self::WeakRelease,
+        },
+        Resolve: Self::WeakUpgrade,
+    };
+
+    unsafe fn from_strong_ptr<'a>(this: *mut c_void) -> &'a mut Self {
+        &mut *(this as *mut *mut c_void as *mut Self)
+    }
+
+    unsafe fn from_weak_ptr<'a>(this: *mut c_void) -> &'a mut Self {
+        &mut *((this as *mut *mut c_void).sub(1) as *mut Self)
+    }
+
+    unsafe fn decode<'a>(value: isize) -> &'a mut Self {
+        transmute(value << 1)
+    }
+
+    unsafe fn query_interface(
+        &self,
+        iid: *const crate::GUID,
+        interface: *mut *mut c_void,
+    ) -> crate::HRESULT {
+        ((*(*(self.object as *mut *mut crate::IUnknown_Vtbl))).QueryInterface)(
+            self.object,
+            iid,
+            interface,
+        )
+    }
+
+    unsafe extern "system" fn StrongQueryInterface(
+        ptr: *mut c_void,
+        iid: *const crate::GUID,
+        interface: *mut *mut c_void,
+    ) -> crate::HRESULT {
+        let this = Self::from_strong_ptr(ptr);
+
+        if iid.is_null() || interface.is_null() {
+            return E_POINTER;
+        }
+
+        // Only directly respond to queries for the the tear-off's strong interface. This is
+        // effectively a self-query.
+        if *iid == IWeakReferenceSource::IID {
+            *interface = ptr;
+            this.strong_count.add_ref();
+            return crate::HRESULT(0);
+        }
+
+        // As the tear-off is sharing the identity of the object, simply delegate any remaining
+        // queries to the object.
+        this.query_interface(iid, interface)
+    }
+
+    unsafe extern "system" fn WeakQueryInterface(
+        ptr: *mut c_void,
+        iid: *const crate::GUID,
+        interface: *mut *mut c_void,
+    ) -> crate::HRESULT {
+        let this = Self::from_weak_ptr(ptr);
+
+        if iid.is_null() || interface.is_null() {
+            return E_POINTER;
+        }
+
+        // While the weak vtable is packed into the same allocation as the strong vtable and
+        // tear-off, it represents a distinct COM identity and thus does not share or delegate to
+        // the object.
+
+        *interface = if *iid == IWeakReference::IID
+            || *iid == crate::IUnknown::IID
+            || *iid == IAgileObject::IID
+        {
+            ptr
+        } else {
+            null_mut()
+        };
+
+        // TODO: implement IMarshal
+
+        if (*interface).is_null() {
+            E_NOINTERFACE
+        } else {
+            this.weak_count.add_ref();
+            crate::HRESULT(0)
+        }
+    }
+
+    unsafe extern "system" fn StrongAddRef(ptr: *mut c_void) -> u32 {
+        let this = Self::from_strong_ptr(ptr);
+
+        // Implement `AddRef` directly as we own the strong reference.
+        this.strong_count.add_ref()
+    }
+
+    unsafe extern "system" fn WeakAddRef(ptr: *mut c_void) -> u32 {
+        let this = Self::from_weak_ptr(ptr);
+
+        // Implement `AddRef` directly as we own the weak reference.
+        this.weak_count.add_ref()
+    }
+
+    unsafe extern "system" fn StrongRelease(ptr: *mut c_void) -> u32 {
+        let this = Self::from_strong_ptr(ptr);
+
+        // Forward strong `Release` to the object so that it can destroy itself. It will then
+        // decrement its weak reference and allow the tear-off to be released as needed.
+        ((*(*(this.object as *mut *mut crate::IUnknown_Vtbl))).Release)(this.object)
+    }
+
+    unsafe extern "system" fn WeakRelease(ptr: *mut c_void) -> u32 {
+        let this = Self::from_weak_ptr(ptr);
+
+        // Implement `Release` directly as we own the weak reference.
+        let remaining = this.weak_count.release();
+
+        // If there are no remaining references, it means that the object has already been
+        // destroyed. Go ahead and destroy the tear-off.
+        if remaining == 0 {
+            let _ = Box::from_raw(this);
+        }
+
+        remaining
+    }
+
+    unsafe extern "system" fn StrongDowngrade(
+        ptr: *mut c_void,
+        interface: *mut *mut c_void,
+    ) -> crate::HRESULT {
+        let this = Self::from_strong_ptr(ptr);
+
+        // The strong vtable hands out a reference to the weak vtable. This is always safe and
+        // straightforward since a strong reference guarantees there is at least one weak
+        // reference.
+        *interface = &mut this.weak_vtable as *mut _ as _;
+        this.weak_count.add_ref();
+        crate::HRESULT(0)
+    }
+
+    unsafe extern "system" fn WeakUpgrade(
+        ptr: *mut c_void,
+        iid: *const crate::GUID,
+        interface: *mut *mut c_void,
+    ) -> crate::HRESULT {
+        let this = Self::from_weak_ptr(ptr);
+
+        this.strong_count
+            .0
+            .fetch_update(Ordering::Acquire, Ordering::Relaxed, |count| {
+                // Attempt to acquire a strong reference count to stabilize the object for the duration
+                // of the `QueryInterface` call.
+                bool::then_some(count != 0, count + 1)
+            })
+            .map(|_| {
+                // Let the object respond to the upgrade query.
+                let result = this.query_interface(iid, interface);
+                // Decrement the temporary reference account used to stabilize the object.
+                this.strong_count.0.fetch_sub(1, Ordering::Relaxed);
+                // Return the result of the query.
+                result
+            })
+            .unwrap_or_else(|_| {
+                *interface = null_mut();
+                crate::HRESULT(0)
+            })
+    }
+}

vendor/windows-core-0.58.0/src/imp/windows.rs

@@ -0,0 +1,11 @@
+mod factory_cache;
+pub use factory_cache::*;
+
+mod generic_factory;
+pub use generic_factory::*;
+
+mod waiter;
+pub use waiter::*;
+
+mod bindings;
+pub use bindings::*;