html-to-markdown 2.25.1 → 2.26.2

data/rust-vendor/wasm-bindgen-macro-support/src/lib.rs

@@ -8,6 +8,7 @@ mod error;
 mod ast;
 mod codegen;
 mod encode;
+mod generics;
 mod hash;
 mod parser;
 

data/rust-vendor/wasm-bindgen-macro-support/src/parser.rs

@@ -97,6 +97,8 @@ macro_rules! attrgen {
             (is_type_of, false, IsTypeOf(Span, syn::Expr)),
             (extends, false, Extends(Span, syn::Path)),
             (no_deref, false, NoDeref(Span)),
+            (no_upcast, false, NoUpcast(Span)),
+            (no_promising, false, NoPromising(Span)),
             (vendor_prefix, false, VendorPrefix(Span, Ident)),
             (variadic, false, Variadic(Span)),
             (typescript_custom_section, false, TypescriptCustomSection(Span)),
@@ -117,6 +119,7 @@ macro_rules! attrgen {
             (unchecked_return_type, true, ReturnType(Span, String, Span)),
             (return_description, true, ReturnDesc(Span, String, Span)),
             (unchecked_param_type, true, ParamType(Span, String, Span)),
+            (unchecked_optional_param_type, true, OptionalParamType(Span, String, Span)),
             (param_description, true, ParamDesc(Span, String, Span)),
 
             // For testing purposes only.
@@ -492,6 +495,8 @@ impl ConvertToAst<&ast::Program> for &mut syn::ItemStruct {
 
         let is_inspectable = attrs.inspectable().is_some();
         let getter_with_clone = attrs.getter_with_clone();
+        let js_namespace = attrs.js_namespace().map(|(ns, _)| ns.0);
+        let qualified_name = wasm_bindgen_shared::qualified_name(js_namespace.as_deref(), &js_name);
         for (i, field) in self.fields.iter_mut().enumerate() {
             match field.vis {
                 syn::Visibility::Public(..) => {}
@@ -514,8 +519,8 @@ impl ConvertToAst<&ast::Program> for &mut syn::ItemStruct {
             };
 
             let comments = extract_doc_comments(&field.attrs);
-            let getter = wasm_bindgen_shared::struct_field_get(&js_name, &js_field_name);
-            let setter = wasm_bindgen_shared::struct_field_set(&js_name, &js_field_name);
+            let getter = wasm_bindgen_shared::struct_field_get(&qualified_name, &js_field_name);
+            let setter = wasm_bindgen_shared::struct_field_set(&qualified_name, &js_field_name);
 
             fields.push(ast::StructField {
                 rust_name: member,
@@ -536,11 +541,11 @@ impl ConvertToAst<&ast::Program> for &mut syn::ItemStruct {
         let generate_typescript = attrs.skip_typescript().is_none();
         let private = attrs.private().is_some();
         let comments: Vec<String> = extract_doc_comments(&self.attrs);
-        let js_namespace = attrs.js_namespace().map(|(ns, _)| ns.0);
         attrs.check_used();
         Ok(ast::Struct {
             rust_name: self.ident.clone(),
             js_name,
+            qualified_name,
             fields,
             comments,
             is_inspectable,
@@ -618,27 +623,28 @@ impl<'a> ConvertToAst<(&ast::Program, BindgenAttrs, &'a Option<ast::ImportModule
                     "first argument of method must be a shared reference"
                 ),
             };
-            let class_name = match get_ty(class) {
+            let class_ty = get_ty(class);
+            let js_class = opts.js_class().map(|p| p.0.to_string());
+            let kind = ast::MethodKind::Operation(ast::Operation {
+                is_static: false,
+                kind: operation_kind,
+            });
+
+            let class_name = match class_ty {
                 syn::Type::Path(syn::TypePath {
                     qself: None,
                     ref path,
                 }) => path,
-                _ => bail_span!(class, "first argument of method must be a path"),
+                _ => bail_span!(class_ty, "first argument of method must be a path"),
             };
-            let class_name = extract_path_ident(class_name)?;
-            let class_name = opts
-                .js_class()
-                .map(|p| p.0.into())
-                .unwrap_or_else(|| class_name.to_string());
 
-            let kind = ast::MethodKind::Operation(ast::Operation {
-                is_static: false,
-                kind: operation_kind,
-            });
+            let class_name_str = js_class
+                .map(Ok)
+                .unwrap_or_else(|| extract_path_ident(class_name, true).map(|i| i.to_string()))?;
 
             ast::ImportFunctionKind::Method {
-                class: class_name,
-                ty: class.clone(),
+                class: class_name_str,
+                ty: class_ty.clone(),
                 kind,
             }
         } else if let Some(cls) = opts.static_method_of() {
@@ -677,7 +683,7 @@ impl<'a> ConvertToAst<(&ast::Program, BindgenAttrs, &'a Option<ast::ImportModule
                 }) => path,
                 _ => bail_span!(self, "return value of constructor must be a bare path"),
             };
-            let class_name = extract_path_ident(class_name)?;
+            let class_name = extract_path_ident(class_name, true)?;
             let class_name = opts
                 .js_class()
                 .map(|p| p.0.into())
@@ -706,7 +712,20 @@ impl<'a> ConvertToAst<(&ast::Program, BindgenAttrs, &'a Option<ast::ImportModule
                 ast::ImportFunctionKind::Normal => (0, "n"),
                 ast::ImportFunctionKind::Method { ref class, .. } => (1, &class[..]),
             };
-            let data = (ns, self.sig.to_token_stream().to_string(), module);
+            // Include cfg attributes in the hash so that functions with different
+            // cfg gates get different shim names, even if their signatures are identical.
+            let cfg_attrs: String = self
+                .attrs
+                .iter()
+                .filter(|attr| attr.path().is_ident("cfg"))
+                .map(|attr| attr.to_token_stream().to_string())
+                .collect();
+            let data = (
+                ns,
+                self.sig.to_token_stream().to_string(),
+                module,
+                cfg_attrs,
+            );
             format!(
                 "__wbg_{}_{}",
                 wasm.name
@@ -763,6 +782,8 @@ impl<'a> ConvertToAst<(&ast::Program, BindgenAttrs, &'a Option<ast::ImportModule
             }
         });
 
+        validate_generics(&self.sig.generics)?;
+
         let ret = ast::ImportKind::Function(ast::ImportFunction {
             function: wasm,
             assert_no_shim,
@@ -776,6 +797,7 @@ impl<'a> ConvertToAst<(&ast::Program, BindgenAttrs, &'a Option<ast::ImportModule
             doc_comment,
             wasm_bindgen: program.wasm_bindgen.clone(),
             wasm_bindgen_futures: program.wasm_bindgen_futures.clone(),
+            generics: self.sig.generics,
         });
         opts.check_used();
 
@@ -804,6 +826,8 @@ impl ConvertToAst<(&ast::Program, BindgenAttrs)> for syn::ForeignItemType {
         let mut extends = Vec::new();
         let mut vendor_prefixes = Vec::new();
         let no_deref = attrs.no_deref().is_some();
+        let no_upcast = attrs.no_upcast().is_some();
+        let no_promising = attrs.no_promising().is_some();
         for (used, attr) in attrs.attrs.iter() {
             match attr {
                 BindgenAttr::Extends(_, e) => {
@@ -817,7 +841,21 @@ impl ConvertToAst<(&ast::Program, BindgenAttrs)> for syn::ForeignItemType {
                 _ => {}
             }
         }
+
         attrs.check_used();
+        validate_generics(&self.generics)?;
+
+        // Ensure defaults are set for all generic type params on imported class definitions.
+        // JsValue as the default default.
+        let mut generics = None;
+        for (n, param) in self.generics.type_params().enumerate() {
+            if param.default.is_none() {
+                let generics = generics.get_or_insert_with(|| self.generics.clone());
+                let type_param_mut = generics.type_params_mut().nth(n).unwrap();
+                type_param_mut.default = Some(syn::parse_quote! { JsValue });
+            }
+        }
+
         Ok(ast::ImportKind::Type(ast::ImportType {
             vis: self.vis,
             attrs: self.attrs,
@@ -830,7 +868,10 @@ impl ConvertToAst<(&ast::Program, BindgenAttrs)> for syn::ForeignItemType {
             extends,
             vendor_prefixes,
             no_deref,
+            no_upcast,
+            no_promising,
             wasm_bindgen: program.wasm_bindgen.clone(),
+            generics: generics.unwrap_or(self.generics),
         }))
     }
 }
@@ -1023,15 +1064,15 @@ fn function_from_decl(
     if sig.variadic.is_some() {
         bail_span!(sig.variadic, "can't #[wasm_bindgen] variadic functions");
     }
-    if !sig.generics.params.is_empty() {
+
+    // For imported functions (Extern position), generics are supported and validated.
+    if !matches!(position, FunctionPosition::Extern) && !sig.generics.params.is_empty() {
         bail_span!(
             sig.generics,
-            "can't #[wasm_bindgen] functions with lifetime or type parameters",
+            "can't #[wasm_bindgen] functions with lifetime or type parameters"
         );
     }
 
-    assert_no_lifetimes(&sig)?;
-
     let syn::Signature { inputs, output, .. } = sig;
 
     // A helper function to replace `Self` in the function signature of methods.
@@ -1188,6 +1229,7 @@ fn function_from_decl(
                     pat_type,
                     js_name: attrs.js_name,
                     js_type: attrs.js_type,
+                    optional: attrs.optional,
                     desc: attrs.desc,
                 })
                 .collect(),
@@ -1201,15 +1243,83 @@ fn function_from_decl(
 struct FnArgAttrs {
     js_name: Option<String>,
     js_type: Option<String>,
+    optional: bool,
     desc: Option<String>,
 }
 
 /// Extracts function arguments attributes
 fn extract_args_attrs(sig: &mut syn::Signature) -> Result<Vec<FnArgAttrs>, Diagnostic> {
     let mut args_attrs = vec![];
+    let mut seen_optional: Option<Span> = None;
     for input in sig.inputs.iter_mut() {
         if let syn::FnArg::Typed(pat_type) = input {
             let attrs = BindgenAttrs::find(&mut pat_type.attrs)?;
+
+            // Check for mutually exclusive param type attributes
+            let param_type = attrs.unchecked_param_type();
+            let optional_param_type = attrs.unchecked_optional_param_type();
+
+            if param_type.is_some() && optional_param_type.is_some() {
+                // Find the positions and spans of both attributes in the attrs list
+                let mut param_pos_and_span: Option<(usize, Span)> = None;
+                let mut optional_pos_and_span: Option<(usize, Span)> = None;
+                for (pos, (_, attr)) in attrs.attrs.iter().enumerate() {
+                    match attr {
+                        BindgenAttr::ParamType(span, _, _) => {
+                            param_pos_and_span = Some((pos, *span));
+                        }
+                        BindgenAttr::OptionalParamType(span, _, _) => {
+                            optional_pos_and_span = Some((pos, *span));
+                        }
+                        _ => {}
+                    }
+                }
+                // Report error at the position of the attribute that appears later
+                let error_span = match (param_pos_and_span, optional_pos_and_span) {
+                    (Some((p_pos, p_span)), Some((o_pos, o_span))) => {
+                        if p_pos > o_pos {
+                            p_span
+                        } else {
+                            o_span
+                        }
+                    }
+                    (Some((_, p_span)), None) => p_span,
+                    (None, Some((_, o_span))) => o_span,
+                    (None, None) => unreachable!(
+                        "both param_type and optional_param_type are Some, but attrs not found"
+                    ),
+                };
+                return Err(Diagnostic::span_error(
+                    error_span,
+                    "cannot use both `unchecked_param_type` and `unchecked_optional_param_type` on the same parameter",
+                ));
+            }
+
+            // Determine the type and whether it's optional
+            let js_type = param_type
+                .or(optional_param_type)
+                .map_or::<Result<_, Diagnostic>, _>(Ok(None), |(ty, span)| {
+                    check_invalid_type(ty, span)?;
+                    Ok(Some(ty.to_string()))
+                })?;
+
+            let is_optional = optional_param_type.is_some();
+
+            // Check that a non-optional param doesn't follow an optional one
+            if let Some(optional_span) = seen_optional {
+                if !is_optional {
+                    return Err(Diagnostic::span_error(
+                        optional_span,
+                        "a required parameter cannot follow an optional parameter",
+                    ));
+                }
+            }
+            if is_optional {
+                if let Some((_, span)) = optional_param_type {
+                    seen_optional = Some(span);
+                }
+            }
+
             let arg_attrs = FnArgAttrs {
                 js_name: attrs
                     .js_name()
@@ -1219,12 +1329,8 @@ fn extract_args_attrs(sig: &mut syn::Signature) -> Result<Vec<FnArgAttrs>, Diagn
                         }
                         Ok(Some(js_name_override.to_string()))
                     })?,
-                js_type: attrs
-                    .unchecked_param_type()
-                    .map_or::<Result<_, Diagnostic>, _>(Ok(None), |(ty, span)| {
-                        check_invalid_type(ty, span)?;
-                        Ok(Some(ty.to_string()))
-                    })?,
+                js_type,
+                optional: is_optional,
                 desc: attrs
                     .param_description()
                     .map_or::<Result<_, Diagnostic>, _>(Ok(None), |(description, span)| {
@@ -1446,7 +1552,7 @@ fn prepare_for_impl_recursion(
         other => bail_span!(other, "failed to parse this item as a known item"),
     };
 
-    let ident = extract_path_ident(class)?;
+    let ident = extract_path_ident(class, false)?;
 
     let js_class = impl_opts
         .js_class()
@@ -2145,34 +2251,23 @@ fn unescape_unicode(chars: &mut Chars) -> Option<(char, char)> {
     None
 }
 
-/// Check there are no lifetimes on the function.
-fn assert_no_lifetimes(sig: &syn::Signature) -> Result<(), Diagnostic> {
-    struct Walk {
-        diagnostics: Vec<Diagnostic>,
-    }
-
-    impl<'ast> syn::visit::Visit<'ast> for Walk {
-        fn visit_lifetime(&mut self, i: &'ast syn::Lifetime) {
-            self.diagnostics.push(err_span!(
-                i,
-                "it is currently not sound to use lifetimes in function \
-                 signatures"
-            ));
-        }
-    }
-    let mut walk = Walk {
-        diagnostics: Vec::new(),
-    };
-    syn::visit::Visit::visit_signature(&mut walk, sig);
-    Diagnostic::from_vec(walk.diagnostics)
-}
-
 /// Extracts the last ident from the path
-fn extract_path_ident(path: &syn::Path) -> Result<Ident, Diagnostic> {
+/// If generics is enabled, generics are validated
+fn extract_path_ident(path: &syn::Path, allow_generics: bool) -> Result<Ident, Diagnostic> {
     for segment in path.segments.iter() {
-        match segment.arguments {
+        match &segment.arguments {
             syn::PathArguments::None => {}
-            _ => bail_span!(path, "paths with type parameters are not supported yet"),
+            syn::PathArguments::AngleBracketed(_) => {
+                if !allow_generics {
+                    bail_span!(
+                        path,
+                        "paths with type parameters are not supported in this position"
+                    )
+                }
+            }
+            syn::PathArguments::Parenthesized(_) => {
+                bail_span!(path, "parenthesized paths are not supported yet")
+            }
         }
     }
 
@@ -2184,6 +2279,66 @@ fn extract_path_ident(path: &syn::Path) -> Result<Ident, Diagnostic> {
     }
 }
 
+fn bail_generic_unsupported(span: impl Spanned + ToTokens) -> Result<(), Diagnostic> {
+    bail_span!(span, "unsupported in wasm-bindgen generics");
+}
+
+fn validate_generic_type_param_bound(bound: &syn::TypeParamBound) -> Result<(), Diagnostic> {
+    match bound {
+        syn::TypeParamBound::Trait(trait_bound) => {
+            // Higher-ranked trait bounds (for<'a>) are now supported
+            if let syn::TraitBoundModifier::Maybe(question) = trait_bound.modifier {
+                bail_generic_unsupported(question)?;
+            }
+        }
+        syn::TypeParamBound::Lifetime(_) => {
+            // Lifetime bounds (e.g., T: 'a) are now supported
+        }
+        syn::TypeParamBound::Verbatim(_) => {}
+        _ => {}
+    }
+    Ok(())
+}
+
+/// Validates generic type parameters and their bounds both for inline parameters and where clauses.
+/// Bails for const params. Lifetimes are supported via hoisting.
+fn validate_generics(generics: &syn::Generics) -> Result<(), Diagnostic> {
+    if let Some(where_clause) = &generics.where_clause {
+        for predicate in &where_clause.predicates {
+            match predicate {
+                syn::WherePredicate::Type(predicate_type) => {
+                    // Lifetime bounds on types (for<'a>) are now supported
+                    predicate_type
+                        .bounds
+                        .iter()
+                        .try_for_each(validate_generic_type_param_bound)?;
+                }
+                syn::WherePredicate::Lifetime(_) => {
+                    // Lifetime bounds (e.g., 'a: 'b) are now supported
+                }
+                _ => bail_generic_unsupported(predicate)?,
+            }
+        }
+    }
+
+    for param in &generics.params {
+        match param {
+            syn::GenericParam::Lifetime(_) => {
+                // Lifetimes are now supported via hoisting
+            }
+            syn::GenericParam::Type(type_param) => {
+                type_param
+                    .bounds
+                    .iter()
+                    .try_for_each(validate_generic_type_param_bound)?;
+            }
+            syn::GenericParam::Const(const_param) => bail_generic_unsupported(const_param)?,
+        }
+    }
+
+    Ok(())
+}
+
 pub fn reset_attrs_used() {
     ATTRS.with(|state| {
         state.parsed.set(0);

data/rust-vendor/wasm-bindgen-shared/.cargo-checksum.json

@@ -1 +1 @@
-{"files":{".cargo_vcs_info.json":"d54d8187580d32be0c7f070c92bc080395d3994b8f47ca08d52ae2168cdff1ec","Cargo.lock":"be3cb85bf4b76efc7087d2aa5d6f180bece5f3aaf7fc74527c477c9df3154ac5","Cargo.toml":"a20981080799b4185934e830d62c293e9c7164a176cad907c6179af2a14fb301","Cargo.toml.orig":"87e364986f2bb0a91128de59e30315306b4fe34731d04cdbe8565ee16f24b2fc","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"378f5840b258e2779c39418f3f2d7b2ba96f1c7917dd6be0713f88305dbda397","build.rs":"cc562769f4d55da465e081bb3187502bab20beb4704f22cc7d07be5ba4b765ae","src/identifier.rs":"05ce1e3dbaaa2c5a9be7ab66ccb11c924c46c75df214fa7477aed9b35152b10f","src/lib.rs":"4ea1d1fb96c5ca31b81a6e39f0d8fa5f3c8fae2188eca21aef8f77303e7dbfe3","src/schema_hash_approval.rs":"9ee223b681d39b026405ec131a7128aa18d5096a648c68409a7801ca475251ee","src/tys.rs":"5c770fca9243824c822e2ea3412b65381ab9eb3ae199bca802cebc3b376cefd8"},"package":"1f01b580c9ac74c8d8f0c0e4afb04eeef2acf145458e52c03845ee9cd23e3d12"}
+{"files":{".cargo_vcs_info.json":"710c3b3e819f9d66144e6b40a6483316368064308873f1b848e653ebe74dc69e","Cargo.lock":"6c78d0ff8e336a9b49f704aed8b326ae098b145944c89a846988a3f49698ba26","Cargo.toml":"025e2972855ab479d92d91993263fe036bd3e92083e97bdc7675a5f16788ba9c","Cargo.toml.orig":"2fb94cafc1e71465291d3084adff584fcfe7be45be99a0bc4ed9fca0a997e9f2","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"378f5840b258e2779c39418f3f2d7b2ba96f1c7917dd6be0713f88305dbda397","build.rs":"cc562769f4d55da465e081bb3187502bab20beb4704f22cc7d07be5ba4b765ae","src/identifier.rs":"05ce1e3dbaaa2c5a9be7ab66ccb11c924c46c75df214fa7477aed9b35152b10f","src/lib.rs":"b6aade48ebe5533c86b98e8edb870544509192d092f458858f5f9fd6c34838d1","src/schema_hash_approval.rs":"ac144177468c8bfd7efaa180de03cb26f6089c143191bd69c4db0b3b52dfe6ee","src/tys.rs":"5c770fca9243824c822e2ea3412b65381ab9eb3ae199bca802cebc3b376cefd8"},"package":"75a326b8c223ee17883a4251907455a2431acc2791c98c26279376490c378c16"}

data/rust-vendor/wasm-bindgen-shared/.cargo_vcs_info.json

@@ -1,6 +1,6 @@
 {
   "git": {
-    "sha1": "a788f58f95cb6603ad2cbdf87571b27665d6cbd9"
+    "sha1": "22cfd556870fa897d0b2db4c84603c1a9643298c"
   },
   "path_in_vcs": "crates/shared"
 }

data/rust-vendor/wasm-bindgen-shared/Cargo.lock

@@ -4,13 +4,13 @@ version = 3
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.22"
+version = "1.0.24"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
 
 [[package]]
 name = "wasm-bindgen-shared"
-version = "0.2.108"
+version = "0.2.114"
 dependencies = [
  "unicode-ident",
 ]

data/rust-vendor/wasm-bindgen-shared/Cargo.toml

@@ -13,7 +13,7 @@
 edition = "2021"
 rust-version = "1.71"
 name = "wasm-bindgen-shared"
-version = "0.2.108"
+version = "0.2.114"
 authors = ["The wasm-bindgen Developers"]
 build = "build.rs"
 links = "wasm_bindgen"
@@ -52,6 +52,9 @@ too_many_arguments = "allow"
 type_complexity = "allow"
 uninlined_format_args = "warn"
 
+[lints.rust]
+unused_lifetimes = "warn"
+
 [lints.rust.unexpected_cfgs]
 level = "warn"
 priority = 0

data/rust-vendor/wasm-bindgen-shared/Cargo.toml.orig

@@ -12,7 +12,7 @@ license = "MIT OR Apache-2.0"
 name = "wasm-bindgen-shared"
 repository = "https://github.com/wasm-bindgen/wasm-bindgen/tree/master/crates/shared"
 rust-version = "1.71"
-version = "0.2.108"
+version = "0.2.114"
 
 # Because only a single `wasm_bindgen` version can be used in a dependency
 # graph, pretend we link a native library so that `cargo` will provide better

data/rust-vendor/wasm-bindgen-shared/src/lib.rs

@@ -13,7 +13,7 @@ pub mod tys;
 // This gets changed whenever our schema changes.
 // At this time versions of wasm-bindgen and wasm-bindgen-cli are required to have the exact same
 // SCHEMA_VERSION in order to work together.
-pub const SCHEMA_VERSION: &str = "0.2.107";
+pub const SCHEMA_VERSION: &str = "0.2.114";
 
 #[macro_export]
 macro_rules! shared_api {
@@ -161,11 +161,13 @@ macro_rules! shared_api {
         struct FunctionArgumentData<'a> {
             name: String,
             ty_override: Option<&'a str>,
+            optional: bool,
             desc: Option<&'a str>,
         }
 
         struct Struct<'a> {
             name: &'a str,
+            rust_name: &'a str,
             fields: Vec<StructField<'a>>,
             comments: Vec<&'a str>,
             is_inspectable: bool,
@@ -191,6 +193,27 @@ macro_rules! shared_api {
     }; // end of mac case
 } // end of mac definition
 
+/// Compute a "qualified name" by prepending the namespace (joined with `__`) to the js_name.
+/// When there is no namespace, this returns the js_name unchanged.
+/// This is used to disambiguate internal wasm symbols when the same js_name
+/// appears in different namespaces. `__` is used as the separator because
+/// double underscores are unlikely to appear in user-defined names.
+pub fn qualified_name(js_namespace: Option<&[impl AsRef<str>]>, js_name: &str) -> String {
+    match js_namespace {
+        Some(ns) if !ns.is_empty() => {
+            let mut name = ns
+                .iter()
+                .map(|s| s.as_ref())
+                .collect::<alloc::vec::Vec<_>>()
+                .join("__");
+            name.push_str("__");
+            name.push_str(js_name);
+            name
+        }
+        _ => js_name.to_string(),
+    }
+}
+
 pub fn new_function(struct_name: &str) -> String {
     let mut name = "__wbg_".to_string();
     name.extend(struct_name.chars().flat_map(|s| s.to_lowercase()));
@@ -251,3 +274,18 @@ pub fn version() -> String {
     }
     v
 }
+
+pub fn escape_string(s: &str) -> String {
+    let mut result = String::with_capacity(s.len());
+    for c in s.chars() {
+        match c {
+            '\\' => result.push_str("\\\\"),
+            '\n' => result.push_str("\\n"),
+            '\r' => result.push_str("\\r"),
+            '\'' => result.push_str("\\'"),
+            '"' => result.push_str("\\\""),
+            _ => result.push(c),
+        }
+    }
+    result
+}

data/rust-vendor/wasm-bindgen-shared/src/schema_hash_approval.rs

@@ -8,7 +8,7 @@
 // If the schema in this library has changed then:
 //  1. Bump the version in `crates/shared/Cargo.toml`
 //  2. Change the `SCHEMA_VERSION` in this library to this new Cargo.toml version
-const APPROVED_SCHEMA_FILE_HASH: &str = "11126141213927254207";
+const APPROVED_SCHEMA_FILE_HASH: &str = "4279711543728568852";
 
 #[test]
 fn schema_version() {