html-to-markdown 2.25.1 → 2.26.2

data/rust-vendor/wasm-bindgen/src/convert/impls.rs

@@ -4,11 +4,15 @@ use core::char;
 use core::mem::{self, ManuallyDrop};
 use core::ptr::NonNull;
 
+use crate::__rt::marker::ErasableGeneric;
 use crate::convert::traits::{WasmAbi, WasmPrimitive};
-use crate::convert::TryFromJsValue;
-use crate::convert::{FromWasmAbi, IntoWasmAbi, LongRefFromWasmAbi, RefFromWasmAbi};
-use crate::convert::{OptionFromWasmAbi, OptionIntoWasmAbi, ReturnWasmAbi};
-use crate::{Clamped, JsError, JsValue, UnwrapThrowExt, __wbindgen_object_is_undefined};
+use crate::convert::{
+    FromWasmAbi, IntoWasmAbi, LongRefFromWasmAbi, OptionFromWasmAbi, OptionIntoWasmAbi,
+    RefFromWasmAbi, ReturnWasmAbi, TryFromJsValue, UpcastFrom,
+};
+use crate::sys::Promising;
+use crate::sys::{JsOption, Undefined};
+use crate::{Clamped, JsError, JsValue, UnwrapThrowExt};
 
 // Primitive types can always be passed over the ABI.
 impl<T: WasmPrimitive> WasmAbi for T {
@@ -131,6 +135,10 @@ macro_rules! type_wasm_native {
                 js.map(|v: $c| v as $t)
             }
         }
+
+        impl UpcastFrom<$t> for JsValue {}
+        impl UpcastFrom<$t> for JsOption<JsValue> {}
+        impl UpcastFrom<$t> for $t {}
     )*)
 }
 
@@ -142,6 +150,11 @@ type_wasm_native!(
     f64 as f64
 );
 
+impl UpcastFrom<u64> for u128 {}
+impl UpcastFrom<u64> for JsOption<u128> {}
+impl UpcastFrom<i64> for i128 {}
+impl UpcastFrom<i64> for JsOption<i128> {}
+
 /// The sentinel value is 2^32 + 1 for 32-bit primitive types.
 ///
 /// 2^32 + 1 is used, because it's the smallest positive integer that cannot be
@@ -167,6 +180,14 @@ macro_rules! type_wasm_native_f64_option {
             unsafe fn from_abi(js: $c) -> Self { js as $t }
         }
 
+        unsafe impl ErasableGeneric for $t {
+            type Repr = $t;
+        }
+
+        impl Promising for $t {
+            type Resolution = $t;
+        }
+
         impl IntoWasmAbi for Option<$t> {
             type Abi = f64;
 
@@ -188,6 +209,10 @@ macro_rules! type_wasm_native_f64_option {
                 }
             }
         }
+
+        impl UpcastFrom<$t> for JsValue {}
+        impl UpcastFrom<$t> for JsOption<JsValue> {}
+        impl UpcastFrom<$t> for $t {}
     )*)
 }
 
@@ -199,6 +224,42 @@ type_wasm_native_f64_option!(
     f32 as f32
 );
 
+#[cfg(target_pointer_width = "32")]
+impl UpcastFrom<isize> for i32 {}
+#[cfg(target_pointer_width = "32")]
+impl UpcastFrom<isize> for JsOption<i32> {}
+
+impl UpcastFrom<isize> for i64 {}
+impl UpcastFrom<isize> for JsOption<i64> {}
+impl UpcastFrom<isize> for i128 {}
+impl UpcastFrom<isize> for JsOption<i128> {}
+
+impl UpcastFrom<i32> for isize {}
+impl UpcastFrom<i32> for JsOption<isize> {}
+impl UpcastFrom<i32> for i64 {}
+impl UpcastFrom<i32> for JsOption<i64> {}
+impl UpcastFrom<i32> for i128 {}
+impl UpcastFrom<i32> for JsOption<i128> {}
+
+impl UpcastFrom<u32> for usize {}
+impl UpcastFrom<u32> for JsOption<usize> {}
+impl UpcastFrom<u32> for u64 {}
+impl UpcastFrom<u32> for JsOption<u64> {}
+impl UpcastFrom<u32> for u128 {}
+impl UpcastFrom<u32> for JsOption<u128> {}
+
+#[cfg(target_pointer_width = "32")]
+impl UpcastFrom<usize> for u32 {}
+#[cfg(target_pointer_width = "32")]
+impl UpcastFrom<usize> for JsOption<u32> {}
+impl UpcastFrom<usize> for u64 {}
+impl UpcastFrom<usize> for JsOption<u64> {}
+impl UpcastFrom<usize> for u128 {}
+impl UpcastFrom<usize> for JsOption<u128> {}
+
+impl UpcastFrom<f32> for f64 {}
+impl UpcastFrom<f32> for JsOption<f64> {}
+
 /// The sentinel value is 0xFF_FFFF for primitives with less than 32 bits.
 ///
 /// This value is used, so all small primitive types (`bool`, `i8`, `u8`,
@@ -231,11 +292,55 @@ macro_rules! type_abi_as_u32 {
             #[inline]
             fn is_none(js: &u32) -> bool { *js == U32_ABI_OPTION_SENTINEL }
         }
+
+        unsafe impl ErasableGeneric for $t {
+            type Repr = $t;
+        }
+
+        impl Promising for $t {
+            type Resolution = $t;
+        }
+
+        impl UpcastFrom<$t> for JsValue {}
+        impl UpcastFrom<$t> for JsOption<JsValue> {}
+        impl UpcastFrom<$t> for $t {}
     )*)
 }
 
 type_abi_as_u32!(i8 u8 i16 u16);
 
+impl UpcastFrom<i8> for i16 {}
+impl UpcastFrom<i8> for JsOption<i16> {}
+impl UpcastFrom<i8> for i32 {}
+impl UpcastFrom<i8> for JsOption<i32> {}
+impl UpcastFrom<i8> for i64 {}
+impl UpcastFrom<i8> for JsOption<i64> {}
+impl UpcastFrom<i8> for i128 {}
+impl UpcastFrom<i8> for JsOption<i128> {}
+
+impl UpcastFrom<u8> for u16 {}
+impl UpcastFrom<u8> for JsOption<u16> {}
+impl UpcastFrom<u8> for u32 {}
+impl UpcastFrom<u8> for JsOption<u32> {}
+impl UpcastFrom<u8> for u64 {}
+impl UpcastFrom<u8> for JsOption<u64> {}
+impl UpcastFrom<u8> for u128 {}
+impl UpcastFrom<u8> for JsOption<u128> {}
+
+impl UpcastFrom<i16> for i32 {}
+impl UpcastFrom<i16> for JsOption<i32> {}
+impl UpcastFrom<i16> for i64 {}
+impl UpcastFrom<i16> for JsOption<i64> {}
+impl UpcastFrom<i16> for i128 {}
+impl UpcastFrom<i16> for JsOption<i128> {}
+
+impl UpcastFrom<u16> for u32 {}
+impl UpcastFrom<u16> for JsOption<u32> {}
+impl UpcastFrom<u16> for u64 {}
+impl UpcastFrom<u16> for JsOption<u64> {}
+impl UpcastFrom<u16> for u128 {}
+impl UpcastFrom<u16> for JsOption<u128> {}
+
 impl IntoWasmAbi for bool {
     type Abi = u32;
 
@@ -268,6 +373,18 @@ impl OptionFromWasmAbi for bool {
     }
 }
 
+unsafe impl ErasableGeneric for bool {
+    type Repr = bool;
+}
+
+impl Promising for bool {
+    type Resolution = bool;
+}
+
+impl UpcastFrom<bool> for JsValue {}
+impl UpcastFrom<bool> for JsOption<JsValue> {}
+impl UpcastFrom<bool> for bool {}
+
 impl IntoWasmAbi for char {
     type Abi = u32;
 
@@ -301,6 +418,18 @@ impl OptionFromWasmAbi for char {
     }
 }
 
+unsafe impl ErasableGeneric for char {
+    type Repr = char;
+}
+
+impl Promising for char {
+    type Resolution = char;
+}
+
+impl UpcastFrom<char> for JsValue {}
+impl UpcastFrom<char> for JsOption<JsValue> {}
+impl UpcastFrom<char> for char {}
+
 impl<T> IntoWasmAbi for *const T {
     type Abi = u32;
 
@@ -319,6 +448,13 @@ impl<T> FromWasmAbi for *const T {
     }
 }
 
+unsafe impl<T: ErasableGeneric> ErasableGeneric for *const T {
+    type Repr = *const T::Repr;
+}
+
+impl<T, Target> UpcastFrom<*const T> for *const Target where Target: UpcastFrom<T> {}
+impl<T, Target> UpcastFrom<*const T> for JsOption<*const Target> where Target: UpcastFrom<T> {}
+
 impl<T> IntoWasmAbi for Option<*const T> {
     type Abi = f64;
 
@@ -329,6 +465,13 @@ impl<T> IntoWasmAbi for Option<*const T> {
     }
 }
 
+unsafe impl<T: ErasableGeneric> ErasableGeneric for Option<T> {
+    type Repr = Option<<T as ErasableGeneric>::Repr>;
+}
+
+impl<T, Target> UpcastFrom<Option<T>> for Option<Target> where Target: UpcastFrom<T> {}
+impl<T, Target> UpcastFrom<Option<T>> for JsOption<Option<Target>> where Target: UpcastFrom<T> {}
+
 impl<T> FromWasmAbi for Option<*const T> {
     type Abi = f64;
 
@@ -482,7 +625,7 @@ impl OptionIntoWasmAbi for &JsValue {
 impl OptionFromWasmAbi for JsValue {
     #[inline]
     fn is_none(js: &u32) -> bool {
-        unsafe { __wbindgen_object_is_undefined(*js) }
+        unsafe { Self::ref_from_abi(*js) }.is_undefined()
     }
 }
 
@@ -511,6 +654,10 @@ impl<T: OptionFromWasmAbi> FromWasmAbi for Option<T> {
     }
 }
 
+impl<T: OptionIntoWasmAbi + ErasableGeneric<Repr = JsValue> + Promising> Promising for Option<T> {
+    type Resolution = Option<<T as Promising>::Resolution>;
+}
+
 impl<T: IntoWasmAbi> IntoWasmAbi for Clamped<T> {
     type Abi = T::Abi;
 
@@ -538,6 +685,24 @@ impl IntoWasmAbi for () {
     }
 }
 
+impl FromWasmAbi for () {
+    type Abi = ();
+
+    #[inline]
+    unsafe fn from_abi(_js: ()) {}
+}
+
+impl Promising for () {
+    type Resolution = Undefined;
+}
+
+impl UpcastFrom<()> for JsValue {}
+impl UpcastFrom<()> for () {}
+
+unsafe impl ErasableGeneric for () {
+    type Repr = ();
+}
+
 impl<T: WasmAbi<Prim3 = (), Prim4 = ()>> WasmAbi for Result<T, u32> {
     type Prim1 = T::Prim1;
     type Prim2 = T::Prim2;
@@ -590,6 +755,31 @@ where
     }
 }
 
+unsafe impl<T: ErasableGeneric, E: ErasableGeneric> ErasableGeneric for Result<T, E> {
+    type Repr = Result<<T as ErasableGeneric>::Repr, <E as ErasableGeneric>::Repr>;
+}
+
+impl<T: ErasableGeneric + Promising, E: ErasableGeneric> Promising for Result<T, E> {
+    type Resolution = Result<<T as Promising>::Resolution, E>;
+}
+
+impl<T, E, TargetT, TargetE> UpcastFrom<Result<T, E>> for Result<TargetT, TargetE>
+where
+    TargetT: UpcastFrom<T>,
+    TargetE: UpcastFrom<E>,
+{
+}
+impl<T, E, TargetT, TargetE> UpcastFrom<Result<T, E>> for JsOption<Result<TargetT, TargetE>>
+where
+    TargetT: UpcastFrom<T>,
+    TargetE: UpcastFrom<E>,
+{
+}
+
+unsafe impl ErasableGeneric for JsError {
+    type Repr = JsValue;
+}
+
 impl IntoWasmAbi for JsError {
     type Abi = <JsValue as IntoWasmAbi>::Abi;
 
@@ -598,6 +788,14 @@ impl IntoWasmAbi for JsError {
     }
 }
 
+impl Promising for JsError {
+    type Resolution = JsError;
+}
+
+impl UpcastFrom<JsError> for JsValue {}
+impl UpcastFrom<JsError> for JsOption<JsValue> {}
+impl UpcastFrom<JsError> for JsError {}
+
 /// # ⚠️ Unstable
 ///
 /// This is part of the internal [`convert`](crate::convert) module, **no

data/rust-vendor/wasm-bindgen/src/convert/slices.rs

@@ -5,14 +5,15 @@ use core::mem::{self, MaybeUninit};
 use core::ops::{Deref, DerefMut};
 use core::str;
 
-use crate::convert::{js_value_vector_from_abi, js_value_vector_into_abi};
+use crate::__rt::marker::ErasableGeneric;
+use crate::__wbindgen_copy_to_typed_array;
 use crate::convert::{
-    FromWasmAbi, IntoWasmAbi, LongRefFromWasmAbi, OptionFromWasmAbi, OptionIntoWasmAbi,
-    RefFromWasmAbi, RefMutFromWasmAbi, VectorFromWasmAbi, VectorIntoWasmAbi, WasmAbi,
+    js_value_vector_from_abi, js_value_vector_into_abi, FromWasmAbi, IntoWasmAbi,
+    LongRefFromWasmAbi, OptionFromWasmAbi, OptionIntoWasmAbi, RefFromWasmAbi, RefMutFromWasmAbi,
+    UpcastFrom, VectorFromWasmAbi, VectorIntoWasmAbi, WasmAbi,
 };
 use crate::describe::*;
 use crate::JsValue;
-use crate::{JsCast, __wbindgen_copy_to_typed_array};
 
 use cfg_if::cfg_if;
 
@@ -25,6 +26,7 @@ use cfg_if::cfg_if;
 // convenient to directly write `WasmSlice` in some of the manually-written FFI
 // functions in `lib.rs` rather than `WasmRet<WasmSlice>`.
 #[repr(C)]
+#[derive(Clone, Copy)]
 pub struct WasmSlice {
     pub ptr: u32,
     pub len: u32,
@@ -396,6 +398,24 @@ impl LongRefFromWasmAbi for str {
     }
 }
 
+unsafe impl ErasableGeneric for &str {
+    type Repr = &'static str;
+}
+
+unsafe impl<T: ErasableGeneric> ErasableGeneric for Box<[T]> {
+    type Repr = Box<[T::Repr]>;
+}
+
+impl UpcastFrom<&str> for &str {}
+
+impl<T, Target> UpcastFrom<Box<[T]>> for Box<[Target]> where Target: UpcastFrom<T> {}
+
+unsafe impl<T: ErasableGeneric> ErasableGeneric for Vec<T> {
+    type Repr = Vec<T::Repr>;
+}
+
+impl<T, Target> UpcastFrom<Vec<T>> for Vec<Target> where Target: UpcastFrom<T> {}
+
 impl<T: VectorIntoWasmAbi> IntoWasmAbi for Box<[T]> {
     type Abi = <T as VectorIntoWasmAbi>::Abi;
 
@@ -430,7 +450,7 @@ where
     }
 }
 
-impl<T: JsCast + WasmDescribe> VectorFromWasmAbi for T {
+impl<T: ErasableGeneric<Repr = JsValue> + WasmDescribe> VectorFromWasmAbi for T {
     type Abi = WasmSlice;
 
     #[inline]
@@ -441,7 +461,7 @@ impl<T: JsCast + WasmDescribe> VectorFromWasmAbi for T {
     }
 }
 
-impl<T: JsCast + WasmDescribe> VectorIntoWasmAbi for T {
+impl<T: ErasableGeneric<Repr = JsValue> + WasmDescribe> VectorIntoWasmAbi for T {
     type Abi = WasmSlice;
 
     #[inline]
@@ -456,10 +476,16 @@ impl<T: JsCast + WasmDescribe> VectorIntoWasmAbi for T {
     }
 }
 
-// JsValue slice support (Rust-to-JS only)
-// JsValue is repr(transparent) over u32, so &[JsValue] is a contiguous array of heap indices
+// JsValue-like slice support (Rust-to-JS only)
+// JsValue-like are repr(transparent) over u32, so &[JsValue] is a contiguous array of heap indices
+
+unsafe impl<T: ErasableGeneric> ErasableGeneric for &[T] {
+    type Repr = &'static [T::Repr];
+}
+
+impl<'a, T, Target> UpcastFrom<&'a [T]> for &'a [Target] where Target: UpcastFrom<T> {}
 
-impl IntoWasmAbi for &[JsValue] {
+impl<T: ErasableGeneric<Repr = JsValue> + WasmDescribe> IntoWasmAbi for &[T] {
     type Abi = WasmSlice;
 
     #[inline]
@@ -471,7 +497,7 @@ impl IntoWasmAbi for &[JsValue] {
     }
 }
 
-impl OptionIntoWasmAbi for &[JsValue] {
+impl<T: ErasableGeneric<Repr = JsValue> + WasmDescribe> OptionIntoWasmAbi for &[T] {
     #[inline]
     fn none() -> WasmSlice {
         null_slice()

data/rust-vendor/wasm-bindgen/src/convert/traits.rs

@@ -3,7 +3,8 @@ use core::ops::{Deref, DerefMut};
 use core::panic::AssertUnwindSafe;
 
 use crate::describe::*;
-use crate::JsValue;
+use crate::sys::JsOption;
+use crate::{ErasableGeneric, JsValue};
 
 /// A trait for anything that can be converted into a type that can cross the
 /// Wasm ABI directly, eg `u32` or `f64`.
@@ -367,3 +368,173 @@ impl<T: FromWasmAbi> FromWasmAbi for AssertUnwindSafe<T> {
         AssertUnwindSafe(T::from_abi(js))
     }
 }
+
+/// A trait for defining upcast relationships from a source type.
+///
+/// This is the inverse of [`Upcast<T>`] - instead of implementing
+/// `impl Upcast<Target> for Source`, you implement `impl UpcastFrom<Source> for Target`.
+///
+/// # Why UpcastFrom?
+///
+/// This resolves Rust's orphan rule issues: you can implement `UpcastFrom<MyType>`
+/// for external types when `MyType` is local to your crate, whereas implementing
+/// `Upcast<ExternalType>` would be prohibited by orphan rules.
+///
+/// # ⚠️ Unstable
+///
+/// This is part of the internal [`convert`](crate::convert) module, **no
+/// stability guarantees** are provided. Use at your own risk. See its
+/// documentation for more details.
+///
+/// # Relationship to Upcast
+///
+/// `UpcastFrom<S>` provides a blanket implementation of `Upcast<T>`:
+/// ```ignore
+/// impl<S, T> Upcast<T> for S where T: UpcastFrom<S> {}
+/// ```
+///
+/// This means implementing `UpcastFrom<Source> for Target` automatically gives you
+/// `Upcast<Target> for Source`, enabling `source.upcast()` to produce `Target`.
+pub trait UpcastFrom<S: ?Sized> {}
+
+/// A trait for type-safe generic upcasting.
+///
+/// # ⚠️ Unstable
+///
+/// This is part of the internal [`convert`](crate::convert) module, **no
+/// stability guarantees** are provided. Use at your own risk. See its
+/// documentation for more details.
+///
+/// # Note
+///
+/// `Upcast<T>` has a blanket implementation for all types where `T: UpcastFrom<Self>`.
+/// New upcast relationships should typically be defined by implementing `FromUpcast`
+/// rather than `Upcast` directly, to avoid orphan rule issues.
+pub trait Upcast<T: ?Sized> {
+    /// Perform a zero-cost type-safe upcast to a wider ref type within the Wasm
+    /// bindgen generics type system.
+    ///
+    /// This enables proper nested conversions that obey subtyping rules,
+    /// supporting strict API type checking.
+    ///
+    /// The common pattern when passing a narrow type is to call `upcast()`
+    /// or `upcast_into()` to obtain the correct type for the function usage,
+    /// while ensuring safe type checked usage.
+    ///
+    /// For example, if passing `Promise<Number>` as an argument to a function
+    /// where `Promise<JsValue>` is expected, or `Function<JsValue>` as an
+    /// argument where `Function<Number>` is expected.
+    ///
+    /// This is a compile time conversion only by the nature of the erasable
+    /// generics type system.
+    #[inline]
+    fn upcast(&self) -> &T
+    where
+        Self: ErasableGeneric,
+        T: Sized + ErasableGeneric<Repr = <Self as ErasableGeneric>::Repr>,
+    {
+        unsafe { &*(self as *const Self as *const T) }
+    }
+
+    /// Perform a zero-cost type-safe upcast to a wider type within the Wasm
+    /// bindgen generics type system.
+    ///
+    /// This enables proper nested conversions that obey subtyping rules,
+    /// supporting strict API type checking.
+    ///
+    /// The common pattern when passing a narrow type is to call `upcast()`
+    /// or `upcast_into()` to obtain the correct type for the function usage,
+    /// while ensuring safe type checked usage.
+    ///
+    /// For example, if passing `Promise<Number>` as an argument to a function
+    /// where `Promise<JsValue>` is expected, or `FunctionArgs<JsValue>` as an
+    /// argument where `FunctionArgs<Number>` is expected.
+    ///
+    /// This is a compile time conversion only by the nature of the erasable
+    /// generics type system.
+    #[inline]
+    fn upcast_into(self) -> T
+    where
+        Self: Sized + ErasableGeneric,
+        T: Sized + ErasableGeneric<Repr = <Self as ErasableGeneric>::Repr>,
+    {
+        unsafe { core::mem::transmute_copy(&core::mem::ManuallyDrop::new(self)) }
+    }
+}
+
+// Blanket impl: UpcastFrom<S> for T implies Upcast<T> for S
+impl<S, T> Upcast<T> for S
+where
+    T: UpcastFrom<S> + ?Sized,
+    S: ?Sized,
+{
+}
+
+// Reference impls using UpcastFrom
+impl<'a, T, Target> UpcastFrom<&'a mut T> for &'a mut Target where Target: UpcastFrom<T> {}
+impl<'a, T, Target> UpcastFrom<&'a T> for &'a Target where Target: UpcastFrom<T> {}
+
+// Tuple upcasts with structural covariance
+macro_rules! impl_tuple_upcast {
+    ([$($T:ident)+] [$($Target:ident)+]) => {
+        // Structural covariance: (T...) -> (Target...)
+        impl<$($T,)+ $($Target,)+> UpcastFrom<($($T,)+)> for ($($Target,)+)
+        where
+            $($Target: JsGeneric + UpcastFrom<$T>,)+
+            $($T: JsGeneric,)+
+        {
+        }
+        impl<$($T: JsGeneric,)+ $($Target: JsGeneric,)+> UpcastFrom<($($T,)+)> for JsOption<($($Target,)+)>
+        where
+            $($Target: JsGeneric + UpcastFrom<$T>,)+
+            $($T: JsGeneric,)+
+        {
+        }
+    };
+}
+impl_tuple_upcast!([T1][Target1]);
+impl_tuple_upcast!([T1 T2] [Target1 Target2]);
+impl_tuple_upcast!([T1 T2 T3] [Target1 Target2 Target3]);
+impl_tuple_upcast!([T1 T2 T3 T4] [Target1 Target2 Target3 Target4]);
+impl_tuple_upcast!([T1 T2 T3 T4 T5] [Target1 Target2 Target3 Target4 Target5]);
+impl_tuple_upcast!([T1 T2 T3 T4 T5 T6] [Target1 Target2 Target3 Target4 Target5 Target6]);
+impl_tuple_upcast!([T1 T2 T3 T4 T5 T6 T7] [Target1 Target2 Target3 Target4 Target5 Target6 Target7]);
+impl_tuple_upcast!([T1 T2 T3 T4 T5 T6 T7 T8] [Target1 Target2 Target3 Target4 Target5 Target6 Target7 Target8]);
+
+/// A convenience trait for types that erase to [`JsValue`].
+///
+/// This is a shorthand for `ErasableGeneric<Repr = JsValue>`, used as a bound
+/// on generic parameters that must be representable as JavaScript values.
+///
+/// # When to Use
+///
+/// Use `JsGeneric` as a trait bound when you need a generic type that:
+/// - Can be passed to/from JavaScript
+/// - Is type-erased to `JsValue` at the FFI boundary
+///
+/// # Examples
+///
+/// ```ignore
+/// use wasm_bindgen::JsGeneric;
+///
+/// fn process_js_values<T: JsGeneric>(items: &[T]) {
+///     // T can be any JS-compatible type
+/// }
+/// ```
+///
+/// # Implementors
+///
+/// This trait is automatically implemented for all types that implement
+/// `ErasableGeneric<Repr = JsValue>`, including:
+/// - All `js_sys` types (`Object`, `Array`, `Function`, etc.)
+/// - `JsValue` itself
+/// - Custom types imported via `#[wasm_bindgen]`
+pub trait JsGeneric:
+    ErasableGeneric<Repr = JsValue> + UpcastFrom<Self> + Upcast<Self> + Upcast<JsValue> + 'static
+{
+}
+
+impl<T: ErasableGeneric<Repr = JsValue> + UpcastFrom<T> + Upcast<JsValue> + 'static> JsGeneric
+    for T
+{
+}

data/rust-vendor/wasm-bindgen/src/describe.rs

@@ -9,7 +9,7 @@ use alloc::vec::Vec;
 use core::panic::AssertUnwindSafe;
 use core::{mem::MaybeUninit, ptr::NonNull};
 
-use crate::{Clamped, JsCast, JsError, JsValue};
+use crate::{Clamped, JsError, JsValue, __rt::marker::ErasableGeneric};
 use cfg_if::cfg_if;
 
 pub use wasm_bindgen_shared::tys::*;
@@ -130,7 +130,7 @@ cfg_if! {
     }
 }
 
-impl<T: JsCast + WasmDescribe> WasmDescribeVector for T {
+impl<T: ErasableGeneric<Repr = JsValue> + WasmDescribe> WasmDescribeVector for T {
     #[cfg_attr(wasm_bindgen_unstable_test_coverage, coverage(off))]
     fn describe_vector() {
         inform(VECTOR);