Merging upstream version 1.70.0+dfsg2.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

10 files changed, 2989 insertions, 0 deletions

diff --git a/vendor/wasm-bindgen-backend/.cargo-checksum.json b/vendor/wasm-bindgen-backend/.cargo-checksum.json
new file mode 100644
index 000000000..128e39aa8
--- /dev/null
+++ b/vendor/wasm-bindgen-backend/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"d4e0f6a5a01e3c7c45270cb76caff12797dfd67fcd73feba5d4ba482e22f3d32","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"378f5840b258e2779c39418f3f2d7b2ba96f1c7917dd6be0713f88305dbda397","src/ast.rs":"4104b5f98d551721556ad85e58d595263dc46ec039abddcf8bddb4344bb9fd45","src/codegen.rs":"3452cbb8990d555091c50f82aa71c33f3b6706b9275a65e10612b9a0d1fb04eb","src/encode.rs":"173285fc270e7f75ac8b11b8be8db215b39bd2ee2d738c7364fa08975d7f2669","src/error.rs":"ecb3e0a2abdce0c9c5bb8a68c0e001a328ed85608bcf4ccb9215088d1f81a9c2","src/lib.rs":"14ade320b537315ec4c575f9f3c7a35ff4e9385114c4c26a35b2ee270a897cb4","src/util.rs":"0e6705dcd8836e01d520e229edc6dbe375ec01ea39e410bd743395416b807f7c"},"package":"4c8ffb332579b0557b52d268b91feab8df3615f265d5270fec2a8c95b17c1142"}
\ No newline at end of file
diff --git a/vendor/wasm-bindgen-backend/Cargo.toml b/vendor/wasm-bindgen-backend/Cargo.toml
new file mode 100644
index 000000000..8e6547ca8
--- /dev/null
+++ b/vendor/wasm-bindgen-backend/Cargo.toml
@@ -0,0 +1,49 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+edition = "2018"
+name = "wasm-bindgen-backend"
+version = "0.2.83"
+authors = ["The wasm-bindgen Developers"]
+description = """
+Backend code generation of the wasm-bindgen tool
+"""
+homepage = "https://rustwasm.github.io/wasm-bindgen/"
+documentation = "https://docs.rs/wasm-bindgen-backend"
+license = "MIT/Apache-2.0"
+repository = "https://github.com/rustwasm/wasm-bindgen/tree/master/crates/backend"
+
+[dependencies.bumpalo]
+version = "3.0.0"
+
+[dependencies.log]
+version = "0.4"
+
+[dependencies.once_cell]
+version = "1.12"
+
+[dependencies.proc-macro2]
+version = "1.0"
+
+[dependencies.quote]
+version = "1.0"
+
+[dependencies.syn]
+version = "1.0"
+features = ["full"]
+
+[dependencies.wasm-bindgen-shared]
+version = "=0.2.83"
+
+[features]
+extra-traits = ["syn/extra-traits"]
+spans = []
diff --git a/vendor/wasm-bindgen-backend/LICENSE-APACHE b/vendor/wasm-bindgen-backend/LICENSE-APACHE
new file mode 100644
index 000000000..16fe87b06
--- /dev/null
+++ b/vendor/wasm-bindgen-backend/LICENSE-APACHE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/vendor/wasm-bindgen-backend/LICENSE-MIT b/vendor/wasm-bindgen-backend/LICENSE-MIT
new file mode 100644
index 000000000..39e0ed660
--- /dev/null
+++ b/vendor/wasm-bindgen-backend/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2014 Alex Crichton
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/vendor/wasm-bindgen-backend/src/ast.rs b/vendor/wasm-bindgen-backend/src/ast.rs
new file mode 100644
index 000000000..7703e2570
--- /dev/null
+++ b/vendor/wasm-bindgen-backend/src/ast.rs
@@ -0,0 +1,453 @@
+//! A representation of the Abstract Syntax Tree of a Rust program,
+//! with all the added metadata necessary to generate WASM bindings
+//! for it.
+
+use crate::Diagnostic;
+use proc_macro2::{Ident, Span};
+use std::hash::{Hash, Hasher};
+use wasm_bindgen_shared as shared;
+
+/// An abstract syntax tree representing a rust program. Contains
+/// extra information for joining up this rust code with javascript.
+#[cfg_attr(feature = "extra-traits", derive(Debug))]
+#[derive(Default, Clone)]
+pub struct Program {
+    /// rust -> js interfaces
+    pub exports: Vec<Export>,
+    /// js -> rust interfaces
+    pub imports: Vec<Import>,
+    /// rust enums
+    pub enums: Vec<Enum>,
+    /// rust structs
+    pub structs: Vec<Struct>,
+    /// custom typescript sections to be included in the definition file
+    pub typescript_custom_sections: Vec<String>,
+    /// Inline JS snippets
+    pub inline_js: Vec<String>,
+}
+
+impl Program {
+    /// Returns true if the Program is empty
+    pub fn is_empty(&self) -> bool {
+        self.exports.is_empty()
+            && self.imports.is_empty()
+            && self.enums.is_empty()
+            && self.structs.is_empty()
+            && self.typescript_custom_sections.is_empty()
+            && self.inline_js.is_empty()
+    }
+}
+
+/// A rust to js interface. Allows interaction with rust objects/functions
+/// from javascript.
+#[cfg_attr(feature = "extra-traits", derive(Debug))]
+#[derive(Clone)]
+pub struct Export {
+    /// Comments extracted from the rust source.
+    pub comments: Vec<String>,
+    /// The rust function
+    pub function: Function,
+    /// The class name in JS this is attached to
+    pub js_class: Option<String>,
+    /// The kind (static, named, regular)
+    pub method_kind: MethodKind,
+    /// The type of `self` (either `self`, `&self`, or `&mut self`)
+    pub method_self: Option<MethodSelf>,
+    /// The struct name, in Rust, this is attached to
+    pub rust_class: Option<Ident>,
+    /// The name of the rust function/method on the rust side.
+    pub rust_name: Ident,
+    /// Whether or not this function should be flagged as the wasm start
+    /// function.
+    pub start: bool,
+}
+
+/// The 3 types variations of `self`.
+#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
+#[derive(Clone)]
+pub enum MethodSelf {
+    /// `self`
+    ByValue,
+    /// `&mut self`
+    RefMutable,
+    /// `&self`
+    RefShared,
+}
+
+/// Things imported from a JS module (in an `extern` block)
+#[cfg_attr(feature = "extra-traits", derive(Debug))]
+#[derive(Clone)]
+pub struct Import {
+    /// The type of module being imported from, if any
+    pub module: Option<ImportModule>,
+    /// The namespace to access the item through, if any
+    pub js_namespace: Option<Vec<String>>,
+    /// The type of item being imported
+    pub kind: ImportKind,
+}
+
+/// The possible types of module to import from
+#[cfg_attr(feature = "extra-traits", derive(Debug))]
+#[derive(Clone)]
+pub enum ImportModule {
+    /// Import from the named module, with relative paths interpreted
+    Named(String, Span),
+    /// Import from the named module, without interpreting paths
+    RawNamed(String, Span),
+    /// Import from an inline JS snippet
+    Inline(usize, Span),
+}
+
+impl Hash for ImportModule {
+    fn hash<H: Hasher>(&self, h: &mut H) {
+        match self {
+            ImportModule::Named(name, _) => (1u8, name).hash(h),
+            ImportModule::Inline(idx, _) => (2u8, idx).hash(h),
+            ImportModule::RawNamed(name, _) => (3u8, name).hash(h),
+        }
+    }
+}
+
+/// The type of item being imported
+#[cfg_attr(feature = "extra-traits", derive(Debug))]
+#[derive(Clone)]
+pub enum ImportKind {
+    /// Importing a function
+    Function(ImportFunction),
+    /// Importing a static value
+    Static(ImportStatic),
+    /// Importing a type/class
+    Type(ImportType),
+    /// Importing a JS enum
+    Enum(ImportEnum),
+}
+
+/// A function being imported from JS
+#[cfg_attr(feature = "extra-traits", derive(Debug))]
+#[derive(Clone)]
+pub struct ImportFunction {
+    /// The full signature of the function
+    pub function: Function,
+    /// The name rust code will use
+    pub rust_name: Ident,
+    /// The type being returned
+    pub js_ret: Option<syn::Type>,
+    /// Whether to catch JS exceptions
+    pub catch: bool,
+    /// Whether the function is variadic on the JS side
+    pub variadic: bool,
+    /// Whether the function should use structural type checking
+    pub structural: bool,
+    /// Causes the Builder (See cli-support::js::binding::Builder) to error out if
+    /// it finds itself generating code for a function with this signature
+    pub assert_no_shim: bool,
+    /// The kind of function being imported
+    pub kind: ImportFunctionKind,
+    /// The shim name to use in the generated code. The 'shim' is a function that appears in
+    /// the generated JS as a wrapper around the actual function to import, performing any
+    /// necessary conversions (EG adding a try/catch to change a thrown error into a Result)
+    pub shim: Ident,
+    /// The doc comment on this import, if one is provided
+    pub doc_comment: String,
+}
+
+/// The type of a function being imported
+#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
+#[derive(Clone)]
+pub enum ImportFunctionKind {
+    /// A class method
+    Method {
+        /// The name of the class for this method, in JS
+        class: String,
+        /// The type of the class for this method, in Rust
+        ty: syn::Type,
+        /// The kind of method this is
+        kind: MethodKind,
+    },
+    /// A standard function
+    Normal,
+}
+
+/// The type of a method
+#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
+#[derive(Clone)]
+pub enum MethodKind {
+    /// A class constructor
+    Constructor,
+    /// Any other kind of method
+    Operation(Operation),
+}
+
+/// The operation performed by a class method
+#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
+#[derive(Clone)]
+pub struct Operation {
+    /// Whether this method is static
+    pub is_static: bool,
+    /// The internal kind of this Operation
+    pub kind: OperationKind,
+}
+
+/// The kind of operation performed by a method
+#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
+#[derive(Clone)]
+pub enum OperationKind {
+    /// A standard method, nothing special
+    Regular,
+    /// A method for getting the value of the provided Ident
+    Getter(Option<Ident>),
+    /// A method for setting the value of the provided Ident
+    Setter(Option<Ident>),
+    /// A dynamically intercepted getter
+    IndexingGetter,
+    /// A dynamically intercepted setter
+    IndexingSetter,
+    /// A dynamically intercepted deleter
+    IndexingDeleter,
+}
+
+/// The type of a static being imported
+#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
+#[derive(Clone)]
+pub struct ImportStatic {
+    /// The visibility of this static in Rust
+    pub vis: syn::Visibility,
+    /// The type of static being imported
+    pub ty: syn::Type,
+    /// The name of the shim function used to access this static
+    pub shim: Ident,
+    /// The name of this static on the Rust side
+    pub rust_name: Ident,
+    /// The name of this static on the JS side
+    pub js_name: String,
+}
+
+/// The metadata for a type being imported
+#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
+#[derive(Clone)]
+pub struct ImportType {
+    /// The visibility of this type in Rust
+    pub vis: syn::Visibility,
+    /// The name of this type on the Rust side
+    pub rust_name: Ident,
+    /// The name of this type on the JS side
+    pub js_name: String,
+    /// The custom attributes to apply to this type
+    pub attrs: Vec<syn::Attribute>,
+    /// The TS definition to generate for this type
+    pub typescript_type: Option<String>,
+    /// The doc comment applied to this type, if one exists
+    pub doc_comment: Option<String>,
+    /// The name of the shim to check instanceof for this type
+    pub instanceof_shim: String,
+    /// The name of the remote function to use for the generated is_type_of
+    pub is_type_of: Option<syn::Expr>,
+    /// The list of classes this extends, if any
+    pub extends: Vec<syn::Path>,
+    /// A custom prefix to add and attempt to fall back to, if the type isn't found
+    pub vendor_prefixes: Vec<Ident>,
+    /// If present, don't generate a `Deref` impl
+    pub no_deref: bool,
+}
+
+/// The metadata for an Enum being imported
+#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
+#[derive(Clone)]
+pub struct ImportEnum {
+    /// The Rust enum's visibility
+    pub vis: syn::Visibility,
+    /// The Rust enum's identifiers
+    pub name: Ident,
+    /// The Rust identifiers for the variants
+    pub variants: Vec<Ident>,
+    /// The JS string values of the variants
+    pub variant_values: Vec<String>,
+    /// Attributes to apply to the Rust enum
+    pub rust_attrs: Vec<syn::Attribute>,
+}
+
+/// Information about a function being imported or exported
+#[cfg_attr(feature = "extra-traits", derive(Debug))]
+#[derive(Clone)]
+pub struct Function {
+    /// The name of the function
+    pub name: String,
+    /// The span of the function's name in Rust code
+    pub name_span: Span,
+    /// Whether the function has a js_name attribute
+    pub renamed_via_js_name: bool,
+    /// The arguments to the function
+    pub arguments: Vec<syn::PatType>,
+    /// The return type of the function, if provided
+    pub ret: Option<syn::Type>,
+    /// Any custom attributes being applied to the function
+    pub rust_attrs: Vec<syn::Attribute>,
+    /// The visibility of this function in Rust
+    pub rust_vis: syn::Visibility,
+    /// Whether this is an `async` function
+    pub r#async: bool,
+    /// Whether to generate a typescript definition for this function
+    pub generate_typescript: bool,
+    /// Whether this is a function with a variadict parameter
+    pub variadic: bool,
+}
+
+/// Information about a Struct being exported
+#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
+#[derive(Clone)]
+pub struct Struct {
+    /// The name of the struct in Rust code
+    pub rust_name: Ident,
+    /// The name of the struct in JS code
+    pub js_name: String,
+    /// All the fields of this struct to export
+    pub fields: Vec<StructField>,
+    /// The doc comments on this struct, if provided
+    pub comments: Vec<String>,
+    /// Whether this struct is inspectable (provides toJSON/toString properties to JS)
+    pub is_inspectable: bool,
+    /// Whether to generate a typescript definition for this struct
+    pub generate_typescript: bool,
+}
+
+/// The field of a struct
+#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
+#[derive(Clone)]
+pub struct StructField {
+    /// The name of the field in Rust code
+    pub rust_name: syn::Member,
+    /// The name of the field in JS code
+    pub js_name: String,
+    /// The name of the struct this field is part of
+    pub struct_name: Ident,
+    /// Whether this value is read-only to JS
+    pub readonly: bool,
+    /// The type of this field
+    pub ty: syn::Type,
+    /// The name of the getter shim for this field
+    pub getter: Ident,
+    /// The name of the setter shim for this field
+    pub setter: Ident,
+    /// The doc comments on this field, if any
+    pub comments: Vec<String>,
+    /// Whether to generate a typescript definition for this field
+    pub generate_typescript: bool,
+    /// Whether to use .clone() in the auto-generated getter for this field
+    pub getter_with_clone: bool,
+}
+
+/// Information about an Enum being exported
+#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
+#[derive(Clone)]
+pub struct Enum {
+    /// The name of this enum in Rust code
+    pub rust_name: Ident,
+    /// The name of this enum in JS code
+    pub js_name: String,
+    /// The variants provided by this enum
+    pub variants: Vec<Variant>,
+    /// The doc comments on this enum, if any
+    pub comments: Vec<String>,
+    /// The value to use for a `none` variant of the enum
+    pub hole: u32,
+    /// Whether to generate a typescript definition for this enum
+    pub generate_typescript: bool,
+}
+
+/// The variant of an enum
+#[cfg_attr(feature = "extra-traits", derive(Debug, PartialEq, Eq))]
+#[derive(Clone)]
+pub struct Variant {
+    /// The name of this variant
+    pub name: Ident,
+    /// The backing value of this variant
+    pub value: u32,
+    /// The doc comments on this variant, if any
+    pub comments: Vec<String>,
+}
+
+/// Unused, the type of an argument to / return from a function
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum TypeKind {
+    /// A by-reference arg, EG `&T`
+    ByRef,
+    /// A by-mutable-reference arg, EG `&mut T`
+    ByMutRef,
+    /// A by-value arg, EG `T`
+    ByValue,
+}
+
+/// Unused, the location of a type for a function argument (import/export, argument/ret)
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub enum TypeLocation {
+    /// An imported argument (JS side type)
+    ImportArgument,
+    /// An imported return
+    ImportRet,
+    /// An exported argument (Rust side type)
+    ExportArgument,
+    /// An exported return
+    ExportRet,
+}
+
+impl Export {
+    /// Mangles a rust -> javascript export, so that the created Ident will be unique over function
+    /// name and class name, if the function belongs to a javascript class.
+    pub(crate) fn rust_symbol(&self) -> Ident {
+        let mut generated_name = String::from("__wasm_bindgen_generated");
+        if let Some(class) = &self.js_class {
+            generated_name.push_str("_");
+            generated_name.push_str(class);
+        }
+        generated_name.push_str("_");
+        generated_name.push_str(&self.function.name.to_string());
+        Ident::new(&generated_name, Span::call_site())
+    }
+
+    /// This is the name of the shim function that gets exported and takes the raw
+    /// ABI form of its arguments and converts them back into their normal,
+    /// "high level" form before calling the actual function.
+    pub(crate) fn export_name(&self) -> String {
+        let fn_name = self.function.name.to_string();
+        match &self.js_class {
+            Some(class) => shared::struct_function_export_name(class, &fn_name),
+            None => shared::free_function_export_name(&fn_name),
+        }
+    }
+}
+
+impl ImportKind {
+    /// Whether this type can be inside an `impl` block.
+    pub fn fits_on_impl(&self) -> bool {
+        match *self {
+            ImportKind::Function(_) => true,
+            ImportKind::Static(_) => false,
+            ImportKind::Type(_) => false,
+            ImportKind::Enum(_) => false,
+        }
+    }
+}
+
+impl Function {
+    /// If the rust object has a `fn xxx(&self) -> MyType` method, get the name for a getter in
+    /// javascript (in this case `xxx`, so you can write `val = obj.xxx`)
+    pub fn infer_getter_property(&self) -> &str {
+        &self.name
+    }
+
+    /// If the rust object has a `fn set_xxx(&mut self, MyType)` style method, get the name
+    /// for a setter in javascript (in this case `xxx`, so you can write `obj.xxx = val`)
+    pub fn infer_setter_property(&self) -> Result<String, Diagnostic> {
+        let name = self.name.to_string();
+
+        // Otherwise we infer names based on the Rust function name.
+        if !name.starts_with("set_") {
+            bail_span!(
+                syn::token::Pub(self.name_span),
+                "setters must start with `set_`, found: {}",
+                name,
+            );
+        }
+        Ok(name[4..].to_string())
+    }
+}
diff --git a/vendor/wasm-bindgen-backend/src/codegen.rs b/vendor/wasm-bindgen-backend/src/codegen.rs
new file mode 100644
index 000000000..5be0fad33
--- /dev/null
+++ b/vendor/wasm-bindgen-backend/src/codegen.rs
@@ -0,0 +1,1389 @@
+use crate::ast;
+use crate::encode;
+use crate::util::ShortHash;
+use crate::Diagnostic;
+use once_cell::sync::Lazy;
+use proc_macro2::{Ident, Literal, Span, TokenStream};
+use quote::{quote, ToTokens};
+use std::collections::{HashMap, HashSet};
+use std::sync::Mutex;
+use wasm_bindgen_shared as shared;
+
+/// A trait for converting AST structs into Tokens and adding them to a TokenStream,
+/// or providing a diagnostic if conversion fails.
+pub trait TryToTokens {
+    /// Attempt to convert a `Self` into tokens and add it to the `TokenStream`
+    fn try_to_tokens(&self, tokens: &mut TokenStream) -> Result<(), Diagnostic>;
+
+    /// Attempt to convert a `Self` into a new `TokenStream`
+    fn try_to_token_stream(&self) -> Result<TokenStream, Diagnostic> {
+        let mut tokens = TokenStream::new();
+        self.try_to_tokens(&mut tokens)?;
+        Ok(tokens)
+    }
+}
+
+impl TryToTokens for ast::Program {
+    // Generate wrappers for all the items that we've found
+    fn try_to_tokens(&self, tokens: &mut TokenStream) -> Result<(), Diagnostic> {
+        let mut errors = Vec::new();
+        for export in self.exports.iter() {
+            if let Err(e) = export.try_to_tokens(tokens) {
+                errors.push(e);
+            }
+        }
+        for s in self.structs.iter() {
+            s.to_tokens(tokens);
+        }
+        let mut types = HashMap::new();
+        for i in self.imports.iter() {
+            if let ast::ImportKind::Type(t) = &i.kind {
+                types.insert(t.rust_name.to_string(), t.rust_name.clone());
+            }
+        }
+        for i in self.imports.iter() {
+            DescribeImport { kind: &i.kind }.to_tokens(tokens);
+
+            // If there is a js namespace, check that name isn't a type. If it is,
+            // this import might be a method on that type.
+            if let Some(nss) = &i.js_namespace {
+                // When the namespace is `A.B`, the type name should be `B`.
+                if let Some(ns) = nss.last().and_then(|t| types.get(t)) {
+                    if i.kind.fits_on_impl() {
+                        let kind = match i.kind.try_to_token_stream() {
+                            Ok(kind) => kind,
+                            Err(e) => {
+                                errors.push(e);
+                                continue;
+                            }
+                        };
+                        (quote! {
+                            #[automatically_derived]
+                            impl #ns { #kind }
+                        })
+                        .to_tokens(tokens);
+                        continue;
+                    }
+                }
+            }
+
+            if let Err(e) = i.kind.try_to_tokens(tokens) {
+                errors.push(e);
+            }
+        }
+        for e in self.enums.iter() {
+            e.to_tokens(tokens);
+        }
+
+        Diagnostic::from_vec(errors)?;
+
+        // Generate a static which will eventually be what lives in a custom section
+        // of the wasm executable. For now it's just a plain old static, but we'll
+        // eventually have it actually in its own section.
+
+        // See comments in `crates/cli-support/src/lib.rs` about what this
+        // `schema_version` is.
+        let prefix_json = format!(
+            r#"{{"schema_version":"{}","version":"{}"}}"#,
+            shared::SCHEMA_VERSION,
+            shared::version()
+        );
+        let encoded = encode::encode(self)?;
+        let len = prefix_json.len() as u32;
+        let bytes = [
+            &len.to_le_bytes()[..],
+            prefix_json.as_bytes(),
+            &encoded.custom_section,
+        ]
+        .concat();
+
+        let generated_static_length = bytes.len();
+        let generated_static_value = syn::LitByteStr::new(&bytes, Span::call_site());
+
+        // We already consumed the contents of included files when generating
+        // the custom section, but we want to make sure that updates to the
+        // generated files will cause this macro to rerun incrementally. To do
+        // that we use `include_str!` to force rustc to think it has a
+        // dependency on these files. That way when the file changes Cargo will
+        // automatically rerun rustc which will rerun this macro. Other than
+        // this we don't actually need the results of the `include_str!`, so
+        // it's just shoved into an anonymous static.
+        let file_dependencies = encoded.included_files.iter().map(|file| {
+            let file = file.to_str().unwrap();
+            quote! { include_str!(#file) }
+        });
+
+        (quote! {
+            #[cfg(target_arch = "wasm32")]
+            #[automatically_derived]
+            const _: () = {
+                static _INCLUDED_FILES: &[&str] = &[#(#file_dependencies),*];
+
+                #[link_section = "__wasm_bindgen_unstable"]
+                pub static _GENERATED: [u8; #generated_static_length] =
+                    *#generated_static_value;
+            };
+        })
+        .to_tokens(tokens);
+
+        Ok(())
+    }
+}
+
+impl ToTokens for ast::Struct {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        let name = &self.rust_name;
+        let name_str = self.js_name.to_string();
+        let name_len = name_str.len() as u32;
+        let name_chars = name_str.chars().map(|c| c as u32);
+        let new_fn = Ident::new(&shared::new_function(&name_str), Span::call_site());
+        let free_fn = Ident::new(&shared::free_function(&name_str), Span::call_site());
+        let free_fn_const = Ident::new(&format!("{}__const", free_fn), free_fn.span());
+        (quote! {
+            #[automatically_derived]
+            impl wasm_bindgen::describe::WasmDescribe for #name {
+                fn describe() {
+                    use wasm_bindgen::__wbindgen_if_not_std;
+                    __wbindgen_if_not_std! {
+                        compile_error! {
+                            "exporting a class to JS requires the `std` feature to \
+                             be enabled in the `wasm-bindgen` crate"
+                        }
+                    }
+                    use wasm_bindgen::describe::*;
+                    inform(RUST_STRUCT);
+                    inform(#name_len);
+                    #(inform(#name_chars);)*
+                }
+            }
+
+            #[automatically_derived]
+            impl wasm_bindgen::convert::IntoWasmAbi for #name {
+                type Abi = u32;
+
+                fn into_abi(self) -> u32 {
+                    use wasm_bindgen::__rt::std::boxed::Box;
+                    use wasm_bindgen::__rt::WasmRefCell;
+                    Box::into_raw(Box::new(WasmRefCell::new(self))) as u32
+                }
+            }
+
+            #[automatically_derived]
+            impl wasm_bindgen::convert::FromWasmAbi for #name {
+                type Abi = u32;
+
+                unsafe fn from_abi(js: u32) -> Self {
+                    use wasm_bindgen::__rt::std::boxed::Box;
+                    use wasm_bindgen::__rt::{assert_not_null, WasmRefCell};
+
+                    let ptr = js as *mut WasmRefCell<#name>;
+                    assert_not_null(ptr);
+                    let js = Box::from_raw(ptr);
+                    (*js).borrow_mut(); // make sure no one's borrowing
+                    js.into_inner()
+                }
+            }
+
+            #[automatically_derived]
+            impl wasm_bindgen::__rt::core::convert::From<#name> for
+                wasm_bindgen::JsValue
+            {
+                fn from(value: #name) -> Self {
+                    let ptr = wasm_bindgen::convert::IntoWasmAbi::into_abi(value);
+
+                    #[link(wasm_import_module = "__wbindgen_placeholder__")]
+                    #[cfg(all(target_arch = "wasm32", not(target_os = "emscripten")))]
+                    extern "C" {
+                        fn #new_fn(ptr: u32) -> u32;
+                    }
+
+                    #[cfg(not(all(target_arch = "wasm32", not(target_os = "emscripten"))))]
+                    unsafe fn #new_fn(_: u32) -> u32 {
+                        panic!("cannot convert to JsValue outside of the wasm target")
+                    }
+
+                    unsafe {
+                        <wasm_bindgen::JsValue as wasm_bindgen::convert::FromWasmAbi>
+                            ::from_abi(#new_fn(ptr))
+                    }
+                }
+            }
+
+            #[cfg(all(target_arch = "wasm32", not(target_os = "emscripten")))]
+            #[automatically_derived]
+            const #free_fn_const: () = {
+                #[no_mangle]
+                #[doc(hidden)]
+                pub unsafe extern "C" fn #free_fn(ptr: u32) {
+                    drop(<#name as wasm_bindgen::convert::FromWasmAbi>::from_abi(ptr));
+                }
+            };
+
+            #[automatically_derived]
+            impl wasm_bindgen::convert::RefFromWasmAbi for #name {
+                type Abi = u32;
+                type Anchor = wasm_bindgen::__rt::Ref<'static, #name>;
+
+                unsafe fn ref_from_abi(js: Self::Abi) -> Self::Anchor {
+                    let js = js as *mut wasm_bindgen::__rt::WasmRefCell<#name>;
+                    wasm_bindgen::__rt::assert_not_null(js);
+                    (*js).borrow()
+                }
+            }
+
+            #[automatically_derived]
+            impl wasm_bindgen::convert::RefMutFromWasmAbi for #name {
+                type Abi = u32;
+                type Anchor = wasm_bindgen::__rt::RefMut<'static, #name>;
+
+                unsafe fn ref_mut_from_abi(js: Self::Abi) -> Self::Anchor {
+                    let js = js as *mut wasm_bindgen::__rt::WasmRefCell<#name>;
+                    wasm_bindgen::__rt::assert_not_null(js);
+                    (*js).borrow_mut()
+                }
+            }
+
+            #[automatically_derived]
+            impl wasm_bindgen::convert::OptionIntoWasmAbi for #name {
+                #[inline]
+                fn none() -> Self::Abi { 0 }
+            }
+
+            #[automatically_derived]
+            impl wasm_bindgen::convert::OptionFromWasmAbi for #name {
+                #[inline]
+                fn is_none(abi: &Self::Abi) -> bool { *abi == 0 }
+            }
+        })
+        .to_tokens(tokens);
+
+        for field in self.fields.iter() {
+            field.to_tokens(tokens);
+        }
+    }
+}
+
+impl ToTokens for ast::StructField {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        let rust_name = &self.rust_name;
+        let struct_name = &self.struct_name;
+        let ty = &self.ty;
+        let getter = &self.getter;
+        let setter = &self.setter;
+
+        let maybe_assert_copy = if self.getter_with_clone {
+            quote! {}
+        } else {
+            quote! { assert_copy::<#ty>() }
+        };
+        let maybe_assert_copy = respan(maybe_assert_copy, ty);
+
+        let maybe_clone = if self.getter_with_clone {
+            quote! { .clone() }
+        } else {
+            quote! {}
+        };
+
+        let getter_const = Ident::new(&format!("{}__const", getter), getter.span());
+
+        (quote! {
+            #[automatically_derived]
+            const #getter_const: () = {
+                #[cfg_attr(all(target_arch = "wasm32", not(target_os = "emscripten")), no_mangle)]
+                #[doc(hidden)]
+                pub unsafe extern "C" fn #getter(js: u32)
+                    -> <#ty as wasm_bindgen::convert::IntoWasmAbi>::Abi
+                {
+                    use wasm_bindgen::__rt::{WasmRefCell, assert_not_null};
+                    use wasm_bindgen::convert::IntoWasmAbi;
+
+                    fn assert_copy<T: Copy>(){}
+                    #maybe_assert_copy;
+
+                    let js = js as *mut WasmRefCell<#struct_name>;
+                    assert_not_null(js);
+                    let val = (*js).borrow().#rust_name#maybe_clone;
+                    <#ty as IntoWasmAbi>::into_abi(val)
+                }
+            };
+        })
+        .to_tokens(tokens);
+
+        Descriptor {
+            ident: &getter,
+            inner: quote! {
+                <#ty as WasmDescribe>::describe();
+            },
+            attrs: vec![],
+        }
+        .to_tokens(tokens);
+
+        if self.readonly {
+            return;
+        }
+
+        let setter_const = Ident::new(&format!("{}__const", setter), setter.span());
+
+        (quote! {
+            #[cfg(all(target_arch = "wasm32", not(target_os = "emscripten")))]
+            #[automatically_derived]
+            const #setter_const: () = {
+                #[no_mangle]
+                #[doc(hidden)]
+                pub unsafe extern "C" fn #setter(
+                    js: u32,
+                    val: <#ty as wasm_bindgen::convert::FromWasmAbi>::Abi,
+                ) {
+                    use wasm_bindgen::__rt::{WasmRefCell, assert_not_null};
+                    use wasm_bindgen::convert::FromWasmAbi;
+
+                    let js = js as *mut WasmRefCell<#struct_name>;
+                    assert_not_null(js);
+                    let val = <#ty as FromWasmAbi>::from_abi(val);
+                    (*js).borrow_mut().#rust_name = val;
+                }
+            };
+        })
+        .to_tokens(tokens);
+    }
+}
+
+impl TryToTokens for ast::Export {
+    fn try_to_tokens(self: &ast::Export, into: &mut TokenStream) -> Result<(), Diagnostic> {
+        let generated_name = self.rust_symbol();
+        let export_name = self.export_name();
+        let mut args = vec![];
+        let mut arg_conversions = vec![];
+        let mut converted_arguments = vec![];
+        let ret = Ident::new("_ret", Span::call_site());
+
+        let offset = if self.method_self.is_some() {
+            args.push(quote! { me: u32 });
+            1
+        } else {
+            0
+        };
+
+        let name = &self.rust_name;
+        let receiver = match self.method_self {
+            Some(ast::MethodSelf::ByValue) => {
+                let class = self.rust_class.as_ref().unwrap();
+                arg_conversions.push(quote! {
+                    let me = unsafe {
+                        <#class as wasm_bindgen::convert::FromWasmAbi>::from_abi(me)
+                    };
+                });
+                quote! { me.#name }
+            }
+            Some(ast::MethodSelf::RefMutable) => {
+                let class = self.rust_class.as_ref().unwrap();
+                arg_conversions.push(quote! {
+                    let mut me = unsafe {
+                        <#class as wasm_bindgen::convert::RefMutFromWasmAbi>
+                            ::ref_mut_from_abi(me)
+                    };
+                    let me = &mut *me;
+                });
+                quote! { me.#name }
+            }
+            Some(ast::MethodSelf::RefShared) => {
+                let class = self.rust_class.as_ref().unwrap();
+                arg_conversions.push(quote! {
+                    let me = unsafe {
+                        <#class as wasm_bindgen::convert::RefFromWasmAbi>
+                            ::ref_from_abi(me)
+                    };
+                    let me = &*me;
+                });
+                quote! { me.#name }
+            }
+            None => match &self.rust_class {
+                Some(class) => quote! { #class::#name },
+                None => quote! { #name },
+            },
+        };
+
+        let mut argtys = Vec::new();
+        for (i, arg) in self.function.arguments.iter().enumerate() {
+            argtys.push(&arg.ty);
+            let i = i + offset;
+            let ident = Ident::new(&format!("arg{}", i), Span::call_site());
+            let ty = &arg.ty;
+            match &*arg.ty {
+                syn::Type::Reference(syn::TypeReference {
+                    mutability: Some(_),
+                    elem,
+                    ..
+                }) => {
+                    args.push(quote! {
+                        #ident: <#elem as wasm_bindgen::convert::RefMutFromWasmAbi>::Abi
+                    });
+                    arg_conversions.push(quote! {
+                        let mut #ident = unsafe {
+                            <#elem as wasm_bindgen::convert::RefMutFromWasmAbi>
+                                ::ref_mut_from_abi(#ident)
+                        };
+                        let #ident = &mut *#ident;
+                    });
+                }
+                syn::Type::Reference(syn::TypeReference { elem, .. }) => {
+                    args.push(quote! {
+                        #ident: <#elem as wasm_bindgen::convert::RefFromWasmAbi>::Abi
+                    });
+                    arg_conversions.push(quote! {
+                        let #ident = unsafe {
+                            <#elem as wasm_bindgen::convert::RefFromWasmAbi>
+                                ::ref_from_abi(#ident)
+                        };
+                        let #ident = &*#ident;
+                    });
+                }
+                _ => {
+                    args.push(quote! {
+                        #ident: <#ty as wasm_bindgen::convert::FromWasmAbi>::Abi
+                    });
+                    arg_conversions.push(quote! {
+                        let #ident = unsafe {
+                            <#ty as wasm_bindgen::convert::FromWasmAbi>
+                                ::from_abi(#ident)
+                        };
+                    });
+                }
+            }
+            converted_arguments.push(quote! { #ident });
+        }
+        let syn_unit = syn::Type::Tuple(syn::TypeTuple {
+            elems: Default::default(),
+            paren_token: Default::default(),
+        });
+        let syn_ret = self.function.ret.as_ref().unwrap_or(&syn_unit);
+        if let syn::Type::Reference(_) = syn_ret {
+            bail_span!(syn_ret, "cannot return a borrowed ref with #[wasm_bindgen]",)
+        }
+
+        // For an `async` function we always run it through `future_to_promise`
+        // since we're returning a promise to JS, and this will implicitly
+        // require that the function returns a `Future<Output = Result<...>>`
+        let (ret_ty, inner_ret_ty, ret_expr) = if self.function.r#async {
+            if self.start {
+                (
+                    quote! { () },
+                    quote! { () },
+                    quote! {
+                        <#syn_ret as wasm_bindgen::__rt::Start>::start(#ret.await)
+                    },
+                )
+            } else {
+                (
+                    quote! { wasm_bindgen::JsValue },
+                    quote! { #syn_ret },
+                    quote! {
+                        <#syn_ret as wasm_bindgen::__rt::IntoJsResult>::into_js_result(#ret.await)
+                    },
+                )
+            }
+        } else if self.start {
+            (
+                quote! { () },
+                quote! { () },
+                quote! { <#syn_ret as wasm_bindgen::__rt::Start>::start(#ret) },
+            )
+        } else {
+            (quote! { #syn_ret }, quote! { #syn_ret }, quote! { #ret })
+        };
+
+        let mut call = quote! {
+            {
+                #(#arg_conversions)*
+                let #ret = #receiver(#(#converted_arguments),*);
+                #ret_expr
+            }
+        };
+
+        if self.function.r#async {
+            if self.start {
+                call = quote! {
+                    wasm_bindgen_futures::spawn_local(async move {
+                        #call
+                    })
+                }
+            } else {
+                call = quote! {
+                    wasm_bindgen_futures::future_to_promise(async move {
+                        #call
+                    }).into()
+                }
+            }
+        }
+
+        let projection = quote! { <#ret_ty as wasm_bindgen::convert::ReturnWasmAbi> };
+        let convert_ret = quote! { #projection::return_abi(#ret) };
+        let describe_ret = quote! {
+            <#ret_ty as WasmDescribe>::describe();
+            <#inner_ret_ty as WasmDescribe>::describe();
+        };
+        let nargs = self.function.arguments.len() as u32;
+        let attrs = &self.function.rust_attrs;
+
+        let start_check = if self.start {
+            quote! { const _ASSERT: fn() = || -> #projection::Abi { loop {} }; }
+        } else {
+            quote! {}
+        };
+
+        let generated_name_const =
+            Ident::new(&format!("{}__const", generated_name), generated_name.span());
+        (quote! {
+            #[automatically_derived]
+            const #generated_name_const: () = {
+                #(#attrs)*
+                #[cfg_attr(
+                    all(target_arch = "wasm32", not(target_os = "emscripten")),
+                    export_name = #export_name,
+                )]
+                pub unsafe extern "C" fn #generated_name(#(#args),*) -> #projection::Abi {
+                    #start_check
+
+                    let #ret = #call;
+                    #convert_ret
+                }
+            };
+        })
+        .to_tokens(into);
+
+        // In addition to generating the shim function above which is what
+        // our generated JS will invoke, we *also* generate a "descriptor"
+        // shim. This descriptor shim uses the `WasmDescribe` trait to
+        // programmatically describe the type signature of the generated
+        // shim above. This in turn is then used to inform the
+        // `wasm-bindgen` CLI tool exactly what types and such it should be
+        // using in JS.
+        //
+        // Note that this descriptor function is a purely an internal detail
+        // of `#[wasm_bindgen]` and isn't intended to be exported to anyone
+        // or actually part of the final was binary. Additionally, this is
+        // literally executed when the `wasm-bindgen` tool executes.
+        //
+        // In any case, there's complications in `wasm-bindgen` to handle
+        // this, but the tl;dr; is that this is stripped from the final wasm
+        // binary along with anything it references.
+        let export = Ident::new(&export_name, Span::call_site());
+        Descriptor {
+            ident: &export,
+            inner: quote! {
+                inform(FUNCTION);
+                inform(0);
+                inform(#nargs);
+                #(<#argtys as WasmDescribe>::describe();)*
+                #describe_ret
+            },
+            attrs: attrs.clone(),
+        }
+        .to_tokens(into);
+
+        Ok(())
+    }
+}
+
+impl TryToTokens for ast::ImportKind {
+    fn try_to_tokens(&self, tokens: &mut TokenStream) -> Result<(), Diagnostic> {
+        match *self {
+            ast::ImportKind::Function(ref f) => f.try_to_tokens(tokens)?,
+            ast::ImportKind::Static(ref s) => s.to_tokens(tokens),
+            ast::ImportKind::Type(ref t) => t.to_tokens(tokens),
+            ast::ImportKind::Enum(ref e) => e.to_tokens(tokens),
+        }
+
+        Ok(())
+    }
+}
+
+impl ToTokens for ast::ImportType {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        let vis = &self.vis;
+        let rust_name = &self.rust_name;
+        let attrs = &self.attrs;
+        let doc_comment = match &self.doc_comment {
+            None => "",
+            Some(comment) => comment,
+        };
+        let const_name = format!("__wbg_generated_const_{}", rust_name);
+        let const_name = Ident::new(&const_name, Span::call_site());
+        let instanceof_shim = Ident::new(&self.instanceof_shim, Span::call_site());
+
+        let internal_obj = match self.extends.first() {
+            Some(target) => {
+                quote! { #target }
+            }
+            None => {
+                quote! { wasm_bindgen::JsValue }
+            }
+        };
+
+        let description = if let Some(typescript_type) = &self.typescript_type {
+            let typescript_type_len = typescript_type.len() as u32;
+            let typescript_type_chars = typescript_type.chars().map(|c| c as u32);
+            quote! {
+                use wasm_bindgen::describe::*;
+                inform(NAMED_EXTERNREF);
+                inform(#typescript_type_len);
+                #(inform(#typescript_type_chars);)*
+            }
+        } else {
+            quote! {
+                JsValue::describe()
+            }
+        };
+
+        let is_type_of = self.is_type_of.as_ref().map(|is_type_of| {
+            quote! {
+                #[inline]
+                fn is_type_of(val: &JsValue) -> bool {
+                    let is_type_of: fn(&JsValue) -> bool = #is_type_of;
+                    is_type_of(val)
+                }
+            }
+        });
+
+        let no_deref = self.no_deref;
+
+        (quote! {
+            #[automatically_derived]
+            #(#attrs)*
+            #[doc = #doc_comment]
+            #[repr(transparent)]
+            #vis struct #rust_name {
+                obj: #internal_obj
+            }
+
+            #[automatically_derived]
+            const #const_name: () = {
+                use wasm_bindgen::convert::{IntoWasmAbi, FromWasmAbi};
+                use wasm_bindgen::convert::{OptionIntoWasmAbi, OptionFromWasmAbi};
+                use wasm_bindgen::convert::RefFromWasmAbi;
+                use wasm_bindgen::describe::WasmDescribe;
+                use wasm_bindgen::{JsValue, JsCast, JsObject};
+                use wasm_bindgen::__rt::core;
+
+                impl WasmDescribe for #rust_name {
+                    fn describe() {
+                        #description
+                    }
+                }
+
+                impl IntoWasmAbi for #rust_name {
+                    type Abi = <JsValue as IntoWasmAbi>::Abi;
+
+                    #[inline]
+                    fn into_abi(self) -> Self::Abi {
+                        self.obj.into_abi()
+                    }
+                }
+
+                impl OptionIntoWasmAbi for #rust_name {
+                    #[inline]
+                    fn none() -> Self::Abi {
+                        0
+                    }
+                }
+
+                impl<'a> OptionIntoWasmAbi for &'a #rust_name {
+                    #[inline]
+                    fn none() -> Self::Abi {
+                        0
+                    }
+                }
+
+                impl FromWasmAbi for #rust_name {
+                    type Abi = <JsValue as FromWasmAbi>::Abi;
+
+                    #[inline]
+                    unsafe fn from_abi(js: Self::Abi) -> Self {
+                        #rust_name {
+                            obj: JsValue::from_abi(js).into(),
+                        }
+                    }
+                }
+
+                impl OptionFromWasmAbi for #rust_name {
+                    #[inline]
+                    fn is_none(abi: &Self::Abi) -> bool { *abi == 0 }
+                }
+
+                impl<'a> IntoWasmAbi for &'a #rust_name {
+                    type Abi = <&'a JsValue as IntoWasmAbi>::Abi;
+
+                    #[inline]
+                    fn into_abi(self) -> Self::Abi {
+                        (&self.obj).into_abi()
+                    }
+                }
+
+                impl RefFromWasmAbi for #rust_name {
+                    type Abi = <JsValue as RefFromWasmAbi>::Abi;
+                    type Anchor = core::mem::ManuallyDrop<#rust_name>;
+
+                    #[inline]
+                    unsafe fn ref_from_abi(js: Self::Abi) -> Self::Anchor {
+                        let tmp = <JsValue as RefFromWasmAbi>::ref_from_abi(js);
+                        core::mem::ManuallyDrop::new(#rust_name {
+                            obj: core::mem::ManuallyDrop::into_inner(tmp).into(),
+                        })
+                    }
+                }
+
+                // TODO: remove this on the next major version
+                impl From<JsValue> for #rust_name {
+                    #[inline]
+                    fn from(obj: JsValue) -> #rust_name {
+                        #rust_name { obj: obj.into() }
+                    }
+                }
+
+                impl AsRef<JsValue> for #rust_name {
+                    #[inline]
+                    fn as_ref(&self) -> &JsValue { self.obj.as_ref() }
+                }
+
+                impl AsRef<#rust_name> for #rust_name {
+                    #[inline]
+                    fn as_ref(&self) -> &#rust_name { self }
+                }
+
+
+                impl From<#rust_name> for JsValue {
+                    #[inline]
+                    fn from(obj: #rust_name) -> JsValue {
+                        obj.obj.into()
+                    }
+                }
+
+                impl JsCast for #rust_name {
+                    fn instanceof(val: &JsValue) -> bool {
+                        #[link(wasm_import_module = "__wbindgen_placeholder__")]
+                        #[cfg(all(target_arch = "wasm32", not(target_os = "emscripten")))]
+                        extern "C" {
+                            fn #instanceof_shim(val: u32) -> u32;
+                        }
+                        #[cfg(not(all(target_arch = "wasm32", not(target_os = "emscripten"))))]
+                        unsafe fn #instanceof_shim(_: u32) -> u32 {
+                            panic!("cannot check instanceof on non-wasm targets");
+                        }
+                        unsafe {
+                            let idx = val.into_abi();
+                            #instanceof_shim(idx) != 0
+                        }
+                    }
+
+                    #is_type_of
+
+                    #[inline]
+                    fn unchecked_from_js(val: JsValue) -> Self {
+                        #rust_name { obj: val.into() }
+                    }
+
+                    #[inline]
+                    fn unchecked_from_js_ref(val: &JsValue) -> &Self {
+                        // Should be safe because `#rust_name` is a transparent
+                        // wrapper around `val`
+                        unsafe { &*(val as *const JsValue as *const #rust_name) }
+                    }
+                }
+
+                impl JsObject for #rust_name {}
+            };
+        })
+        .to_tokens(tokens);
+
+        if !no_deref {
+            (quote! {
+                #[automatically_derived]
+                impl core::ops::Deref for #rust_name {
+                    type Target = #internal_obj;
+
+                    #[inline]
+                    fn deref(&self) -> &#internal_obj {
+                        &self.obj
+                    }
+                }
+            })
+            .to_tokens(tokens);
+        }
+
+        for superclass in self.extends.iter() {
+            (quote! {
+                #[automatically_derived]
+                impl From<#rust_name> for #superclass {
+                    #[inline]
+                    fn from(obj: #rust_name) -> #superclass {
+                        use wasm_bindgen::JsCast;
+                        #superclass::unchecked_from_js(obj.into())
+                    }
+                }
+
+                #[automatically_derived]
+                impl AsRef<#superclass> for #rust_name {
+                    #[inline]
+                    fn as_ref(&self) -> &#superclass {
+                        use wasm_bindgen::JsCast;
+                        #superclass::unchecked_from_js_ref(self.as_ref())
+                    }
+                }
+            })
+            .to_tokens(tokens);
+        }
+    }
+}
+
+impl ToTokens for ast::ImportEnum {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        let vis = &self.vis;
+        let name = &self.name;
+        let expect_string = format!("attempted to convert invalid {} into JSValue", name);
+        let variants = &self.variants;
+        let variant_strings = &self.variant_values;
+        let attrs = &self.rust_attrs;
+
+        let mut current_idx: usize = 0;
+        let variant_indexes: Vec<Literal> = variants
+            .iter()
+            .map(|_| {
+                let this_index = current_idx;
+                current_idx += 1;
+                Literal::usize_unsuffixed(this_index)
+            })
+            .collect();
+
+        // Borrow variant_indexes because we need to use it multiple times inside the quote! macro
+        let variant_indexes_ref = &variant_indexes;
+
+        // A vector of EnumName::VariantName tokens for this enum
+        let variant_paths: Vec<TokenStream> = self
+            .variants
+            .iter()
+            .map(|v| quote!(#name::#v).into_token_stream())
+            .collect();
+
+        // Borrow variant_paths because we need to use it multiple times inside the quote! macro
+        let variant_paths_ref = &variant_paths;
+
+        (quote! {
+            #(#attrs)*
+            #vis enum #name {
+                #(#variants = #variant_indexes_ref,)*
+                #[automatically_derived]
+                #[doc(hidden)]
+                __Nonexhaustive,
+            }
+
+            #[automatically_derived]
+            impl #name {
+                fn from_str(s: &str) -> Option<#name> {
+                    match s {
+                        #(#variant_strings => Some(#variant_paths_ref),)*
+                        _ => None,
+                    }
+                }
+
+                fn to_str(&self) -> &'static str {
+                    match self {
+                        #(#variant_paths_ref => #variant_strings,)*
+                        #name::__Nonexhaustive => panic!(#expect_string),
+                    }
+                }
+
+                #vis fn from_js_value(obj: &wasm_bindgen::JsValue) -> Option<#name> {
+                    obj.as_string().and_then(|obj_str| Self::from_str(obj_str.as_str()))
+                }
+            }
+
+            // It should really be using &str for all of these, but that requires some major changes to cli-support
+            #[automatically_derived]
+            impl wasm_bindgen::describe::WasmDescribe for #name {
+                fn describe() {
+                    <wasm_bindgen::JsValue as wasm_bindgen::describe::WasmDescribe>::describe()
+                }
+            }
+
+            #[automatically_derived]
+            impl wasm_bindgen::convert::IntoWasmAbi for #name {
+                type Abi = <wasm_bindgen::JsValue as wasm_bindgen::convert::IntoWasmAbi>::Abi;
+
+                #[inline]
+                fn into_abi(self) -> Self::Abi {
+                    <wasm_bindgen::JsValue as wasm_bindgen::convert::IntoWasmAbi>::into_abi(self.into())
+                }
+            }
+
+            #[automatically_derived]
+            impl wasm_bindgen::convert::FromWasmAbi for #name {
+                type Abi = <wasm_bindgen::JsValue as wasm_bindgen::convert::FromWasmAbi>::Abi;
+
+                unsafe fn from_abi(js: Self::Abi) -> Self {
+                    let s = <wasm_bindgen::JsValue as wasm_bindgen::convert::FromWasmAbi>::from_abi(js);
+                    #name::from_js_value(&s).unwrap_or(#name::__Nonexhaustive)
+                }
+            }
+
+            #[automatically_derived]
+            impl wasm_bindgen::convert::OptionIntoWasmAbi for #name {
+                #[inline]
+                fn none() -> Self::Abi { <::js_sys::Object as wasm_bindgen::convert::OptionIntoWasmAbi>::none() }
+            }
+
+            #[automatically_derived]
+            impl wasm_bindgen::convert::OptionFromWasmAbi for #name {
+                #[inline]
+                fn is_none(abi: &Self::Abi) -> bool { <::js_sys::Object as wasm_bindgen::convert::OptionFromWasmAbi>::is_none(abi) }
+            }
+
+            #[automatically_derived]
+            impl From<#name> for wasm_bindgen::JsValue {
+                fn from(obj: #name) -> wasm_bindgen::JsValue {
+                    wasm_bindgen::JsValue::from(obj.to_str())
+                }
+            }
+        }).to_tokens(tokens);
+    }
+}
+
+impl TryToTokens for ast::ImportFunction {
+    fn try_to_tokens(&self, tokens: &mut TokenStream) -> Result<(), Diagnostic> {
+        let mut class_ty = None;
+        let mut is_method = false;
+        match self.kind {
+            ast::ImportFunctionKind::Method {
+                ref ty, ref kind, ..
+            } => {
+                if let ast::MethodKind::Operation(ast::Operation {
+                    is_static: false, ..
+                }) = kind
+                {
+                    is_method = true;
+                }
+                class_ty = Some(ty);
+            }
+            ast::ImportFunctionKind::Normal => {}
+        }
+        let vis = &self.function.rust_vis;
+        let ret = match &self.function.ret {
+            Some(ty) => quote! { -> #ty },
+            None => quote!(),
+        };
+
+        let mut abi_argument_names = Vec::new();
+        let mut abi_arguments = Vec::new();
+        let mut arg_conversions = Vec::new();
+        let mut arguments = Vec::new();
+        let ret_ident = Ident::new("_ret", Span::call_site());
+
+        for (i, arg) in self.function.arguments.iter().enumerate() {
+            let ty = &arg.ty;
+            let name = match &*arg.pat {
+                syn::Pat::Ident(syn::PatIdent {
+                    by_ref: None,
+                    ident,
+                    subpat: None,
+                    ..
+                }) => ident.clone(),
+                syn::Pat::Wild(_) => syn::Ident::new(&format!("__genarg_{}", i), Span::call_site()),
+                _ => bail_span!(
+                    arg.pat,
+                    "unsupported pattern in #[wasm_bindgen] imported function",
+                ),
+            };
+
+            abi_argument_names.push(name.clone());
+            abi_arguments.push(quote! {
+                #name: <#ty as wasm_bindgen::convert::IntoWasmAbi>::Abi
+            });
+            let var = if i == 0 && is_method {
+                quote! { self }
+            } else {
+                arguments.push(quote! { #name: #ty });
+                quote! { #name }
+            };
+            arg_conversions.push(quote! {
+                let #name = <#ty as wasm_bindgen::convert::IntoWasmAbi>
+                    ::into_abi(#var);
+            });
+        }
+        let abi_ret;
+        let mut convert_ret;
+        match &self.js_ret {
+            Some(syn::Type::Reference(_)) => {
+                bail_span!(
+                    self.js_ret,
+                    "cannot return references in #[wasm_bindgen] imports yet"
+                );
+            }
+            Some(ref ty) => {
+                if self.function.r#async {
+                    abi_ret =
+                        quote! { <js_sys::Promise as wasm_bindgen::convert::FromWasmAbi>::Abi };
+                    let future = quote! {
+                        wasm_bindgen_futures::JsFuture::from(
+                            <js_sys::Promise as wasm_bindgen::convert::FromWasmAbi>
+                                ::from_abi(#ret_ident)
+                        ).await
+                    };
+                    convert_ret = if self.catch {
+                        quote! { Ok(#future?) }
+                    } else {
+                        quote! { #future.expect("unexpected exception") }
+                    };
+                } else {
+                    abi_ret = quote! {
+                        <#ty as wasm_bindgen::convert::FromWasmAbi>::Abi
+                    };
+                    convert_ret = quote! {
+                        <#ty as wasm_bindgen::convert::FromWasmAbi>
+                            ::from_abi(#ret_ident)
+                    };
+                }
+            }
+            None => {
+                if self.function.r#async {
+                    abi_ret =
+                        quote! { <js_sys::Promise as wasm_bindgen::convert::FromWasmAbi>::Abi };
+                    let future = quote! {
+                        wasm_bindgen_futures::JsFuture::from(
+                            <js_sys::Promise as wasm_bindgen::convert::FromWasmAbi>
+                                ::from_abi(#ret_ident)
+                        ).await
+                    };
+                    convert_ret = if self.catch {
+                        quote! { #future?; Ok(()) }
+                    } else {
+                        quote! { #future.expect("uncaught exception"); }
+                    };
+                } else {
+                    abi_ret = quote! { () };
+                    convert_ret = quote! { () };
+                }
+            }
+        }
+
+        let mut exceptional_ret = quote!();
+        if self.catch && !self.function.r#async {
+            convert_ret = quote! { Ok(#convert_ret) };
+            exceptional_ret = quote! {
+                wasm_bindgen::__rt::take_last_exception()?;
+            };
+        }
+
+        let rust_name = &self.rust_name;
+        let import_name = &self.shim;
+        let attrs = &self.function.rust_attrs;
+        let arguments = &arguments;
+        let abi_arguments = &abi_arguments;
+        let abi_argument_names = &abi_argument_names;
+
+        let doc_comment = &self.doc_comment;
+        let me = if is_method {
+            quote! { &self, }
+        } else {
+            quote!()
+        };
+
+        // Route any errors pointing to this imported function to the identifier
+        // of the function we're imported from so we at least know what function
+        // is causing issues.
+        //
+        // Note that this is where type errors like "doesn't implement
+        // FromWasmAbi" or "doesn't implement IntoWasmAbi" currently get routed.
+        // I suspect that's because they show up in the signature via trait
+        // projections as types of arguments, and all that needs to typecheck
+        // before the body can be typechecked. Due to rust-lang/rust#60980 (and
+        // probably related issues) we can't really get a precise span.
+        //
+        // Ideally what we want is to point errors for particular types back to
+        // the specific argument/type that generated the error, but it looks
+        // like rustc itself doesn't do great in that regard so let's just do
+        // the best we can in the meantime.
+        let extern_fn = respan(
+            quote! {
+                #[cfg(all(target_arch = "wasm32", not(target_os = "emscripten")))]
+                #(#attrs)*
+                #[link(wasm_import_module = "__wbindgen_placeholder__")]
+                extern "C" {
+                    fn #import_name(#(#abi_arguments),*) -> #abi_ret;
+                }
+
+                #[cfg(not(all(target_arch = "wasm32", not(target_os = "emscripten"))))]
+                unsafe fn #import_name(#(#abi_arguments),*) -> #abi_ret {
+                    #(
+                        drop(#abi_argument_names);
+                    )*
+                    panic!("cannot call wasm-bindgen imported functions on \
+                            non-wasm targets");
+                }
+            },
+            &self.rust_name,
+        );
+
+        let maybe_async = if self.function.r#async {
+            Some(quote! {async})
+        } else {
+            None
+        };
+        let invocation = quote! {
+            // This is due to `#[automatically_derived]` attribute cannot be
+            // placed onto bare functions.
+            #[allow(nonstandard_style)]
+            #[allow(clippy::all, clippy::nursery, clippy::pedantic, clippy::restriction)]
+            #(#attrs)*
+            #[doc = #doc_comment]
+            #vis #maybe_async fn #rust_name(#me #(#arguments),*) #ret {
+                #extern_fn
+
+                unsafe {
+                    let #ret_ident = {
+                        #(#arg_conversions)*
+                        #import_name(#(#abi_argument_names),*)
+                    };
+                    #exceptional_ret
+                    #convert_ret
+                }
+            }
+        };
+
+        if let Some(class) = class_ty {
+            (quote! {
+                #[automatically_derived]
+                impl #class {
+                    #invocation
+                }
+            })
+            .to_tokens(tokens);
+        } else {
+            invocation.to_tokens(tokens);
+        }
+
+        Ok(())
+    }
+}
+
+// See comment above in ast::Export for what's going on here.
+struct DescribeImport<'a> {
+    kind: &'a ast::ImportKind,
+}
+
+impl<'a> ToTokens for DescribeImport<'a> {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        let f = match *self.kind {
+            ast::ImportKind::Function(ref f) => f,
+            ast::ImportKind::Static(_) => return,
+            ast::ImportKind::Type(_) => return,
+            ast::ImportKind::Enum(_) => return,
+        };
+        let argtys = f.function.arguments.iter().map(|arg| &arg.ty);
+        let nargs = f.function.arguments.len() as u32;
+        let inform_ret = match &f.js_ret {
+            Some(ref t) => quote! { <#t as WasmDescribe>::describe(); },
+            // async functions always return a JsValue, even if they say to return ()
+            None if f.function.r#async => quote! { <JsValue as WasmDescribe>::describe(); },
+            None => quote! { <() as WasmDescribe>::describe(); },
+        };
+
+        Descriptor {
+            ident: &f.shim,
+            inner: quote! {
+                inform(FUNCTION);
+                inform(0);
+                inform(#nargs);
+                #(<#argtys as WasmDescribe>::describe();)*
+                #inform_ret
+                #inform_ret
+            },
+            attrs: f.function.rust_attrs.clone(),
+        }
+        .to_tokens(tokens);
+    }
+}
+
+impl ToTokens for ast::Enum {
+    fn to_tokens(&self, into: &mut TokenStream) {
+        let enum_name = &self.rust_name;
+        let hole = &self.hole;
+        let cast_clauses = self.variants.iter().map(|variant| {
+            let variant_name = &variant.name;
+            quote! {
+                if js == #enum_name::#variant_name as u32 {
+                    #enum_name::#variant_name
+                }
+            }
+        });
+        (quote! {
+            #[automatically_derived]
+            impl wasm_bindgen::convert::IntoWasmAbi for #enum_name {
+                type Abi = u32;
+
+                #[inline]
+                fn into_abi(self) -> u32 {
+                    self as u32
+                }
+            }
+
+            #[automatically_derived]
+            impl wasm_bindgen::convert::FromWasmAbi for #enum_name {
+                type Abi = u32;
+
+                #[inline]
+                unsafe fn from_abi(js: u32) -> Self {
+                    #(#cast_clauses else)* {
+                        wasm_bindgen::throw_str("invalid enum value passed")
+                    }
+                }
+            }
+
+            #[automatically_derived]
+            impl wasm_bindgen::convert::OptionFromWasmAbi for #enum_name {
+                #[inline]
+                fn is_none(val: &u32) -> bool { *val == #hole }
+            }
+
+            #[automatically_derived]
+            impl wasm_bindgen::convert::OptionIntoWasmAbi for #enum_name {
+                #[inline]
+                fn none() -> Self::Abi { #hole }
+            }
+
+            #[automatically_derived]
+            impl wasm_bindgen::describe::WasmDescribe for #enum_name {
+                fn describe() {
+                    use wasm_bindgen::describe::*;
+                    inform(ENUM);
+                    inform(#hole);
+                }
+            }
+        })
+        .to_tokens(into);
+    }
+}
+
+impl ToTokens for ast::ImportStatic {
+    fn to_tokens(&self, into: &mut TokenStream) {
+        let name = &self.rust_name;
+        let ty = &self.ty;
+        let shim_name = &self.shim;
+        let vis = &self.vis;
+        (quote! {
+            #[automatically_derived]
+            #vis static #name: wasm_bindgen::JsStatic<#ty> = {
+                fn init() -> #ty {
+                    #[link(wasm_import_module = "__wbindgen_placeholder__")]
+                    #[cfg(all(target_arch = "wasm32", not(target_os = "emscripten")))]
+                    extern "C" {
+                        fn #shim_name() -> <#ty as wasm_bindgen::convert::FromWasmAbi>::Abi;
+                    }
+                    #[cfg(not(all(target_arch = "wasm32", not(target_os = "emscripten"))))]
+                    unsafe fn #shim_name() -> <#ty as wasm_bindgen::convert::FromWasmAbi>::Abi {
+                        panic!("cannot access imported statics on non-wasm targets")
+                    }
+
+                    unsafe {
+                        <#ty as wasm_bindgen::convert::FromWasmAbi>::from_abi(#shim_name())
+                    }
+                }
+                thread_local!(static _VAL: #ty = init(););
+                wasm_bindgen::JsStatic {
+                    __inner: &_VAL,
+                }
+            };
+        })
+        .to_tokens(into);
+
+        Descriptor {
+            ident: &shim_name,
+            inner: quote! {
+                <#ty as WasmDescribe>::describe();
+            },
+            attrs: vec![],
+        }
+        .to_tokens(into);
+    }
+}
+
+/// Emits the necessary glue tokens for "descriptor", generating an appropriate
+/// symbol name as well as attributes around the descriptor function itself.
+struct Descriptor<'a, T> {
+    ident: &'a Ident,
+    inner: T,
+    attrs: Vec<syn::Attribute>,
+}
+
+impl<'a, T: ToTokens> ToTokens for Descriptor<'a, T> {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        // It's possible for the same descriptor to be emitted in two different
+        // modules (aka a value imported twice in a crate, each in a separate
+        // module). In this case no need to emit duplicate descriptors (which
+        // leads to duplicate symbol errors), instead just emit one.
+        //
+        // It's up to the descriptors themselves to ensure they have unique
+        // names for unique items imported, currently done via `ShortHash` and
+        // hashing appropriate data into the symbol name.
+        static DESCRIPTORS_EMITTED: Lazy<Mutex<HashSet<String>>> = Lazy::new(Default::default);
+
+        let ident = self.ident;
+
+        if !DESCRIPTORS_EMITTED
+            .lock()
+            .unwrap()
+            .insert(ident.to_string())
+        {
+            return;
+        }
+
+        let name = Ident::new(&format!("__wbindgen_describe_{}", ident), ident.span());
+        let const_name = Ident::new(
+            &format!("__wbindgen_const_describe_{}", ident),
+            ident.span(),
+        );
+        let inner = &self.inner;
+        let attrs = &self.attrs;
+        (quote! {
+            #[cfg(all(target_arch = "wasm32", not(target_os = "emscripten")))]
+            #[automatically_derived]
+            const #const_name: () = {
+                #(#attrs)*
+                #[no_mangle]
+                #[doc(hidden)]
+                pub extern "C" fn #name() {
+                    use wasm_bindgen::describe::*;
+                    // See definition of `link_mem_intrinsics` for what this is doing
+                    wasm_bindgen::__rt::link_mem_intrinsics();
+                    #inner
+                }
+            };
+        })
+        .to_tokens(tokens);
+    }
+}
+
+/// Converts `span` into a stream of tokens, and attempts to ensure that `input`
+/// has all the appropriate span information so errors in it point to `span`.
+fn respan(input: TokenStream, span: &dyn ToTokens) -> TokenStream {
+    let mut first_span = Span::call_site();
+    let mut last_span = Span::call_site();
+    let mut spans = TokenStream::new();
+    span.to_tokens(&mut spans);
+
+    for (i, token) in spans.into_iter().enumerate() {
+        if i == 0 {
+            first_span = token.span();
+        }
+        last_span = token.span();
+    }
+
+    let mut new_tokens = Vec::new();
+    for (i, mut token) in input.into_iter().enumerate() {
+        if i == 0 {
+            token.set_span(first_span);
+        } else {
+            token.set_span(last_span);
+        }
+        new_tokens.push(token);
+    }
+    new_tokens.into_iter().collect()
+}
diff --git a/vendor/wasm-bindgen-backend/src/encode.rs b/vendor/wasm-bindgen-backend/src/encode.rs
new file mode 100644
index 000000000..41d3c8b77
--- /dev/null
+++ b/vendor/wasm-bindgen-backend/src/encode.rs
@@ -0,0 +1,536 @@
+use crate::util::ShortHash;
+use proc_macro2::{Ident, Span};
+use std::cell::{Cell, RefCell};
+use std::collections::HashMap;
+use std::env;
+use std::fs;
+use std::path::PathBuf;
+
+use crate::ast;
+use crate::Diagnostic;
+
+pub struct EncodeResult {
+    pub custom_section: Vec<u8>,
+    pub included_files: Vec<PathBuf>,
+}
+
+pub fn encode(program: &ast::Program) -> Result<EncodeResult, Diagnostic> {
+    let mut e = Encoder::new();
+    let i = Interner::new();
+    shared_program(program, &i)?.encode(&mut e);
+    let custom_section = e.finish();
+    let included_files = i
+        .files
+        .borrow()
+        .values()
+        .map(|p| &p.path)
+        .cloned()
+        .collect();
+    Ok(EncodeResult {
+        custom_section,
+        included_files,
+    })
+}
+
+struct Interner {
+    bump: bumpalo::Bump,
+    files: RefCell<HashMap<String, LocalFile>>,
+    root: PathBuf,
+    crate_name: String,
+    has_package_json: Cell<bool>,
+}
+
+struct LocalFile {
+    path: PathBuf,
+    definition: Span,
+    new_identifier: String,
+}
+
+impl Interner {
+    fn new() -> Interner {
+        let root = env::var_os("CARGO_MANIFEST_DIR")
+            .expect("should have CARGO_MANIFEST_DIR env var")
+            .into();
+        let crate_name = env::var("CARGO_PKG_NAME").expect("should have CARGO_PKG_NAME env var");
+        Interner {
+            bump: bumpalo::Bump::new(),
+            files: RefCell::new(HashMap::new()),
+            root,
+            crate_name,
+            has_package_json: Cell::new(false),
+        }
+    }
+
+    fn intern(&self, s: &Ident) -> &str {
+        self.intern_str(&s.to_string())
+    }
+
+    fn intern_str(&self, s: &str) -> &str {
+        // NB: eventually this could be used to intern `s` to only allocate one
+        // copy, but for now let's just "transmute" `s` to have the same
+        // lifetime as this struct itself (which is our main goal here)
+        self.bump.alloc_str(s)
+    }
+
+    /// Given an import to a local module `id` this generates a unique module id
+    /// to assign to the contents of `id`.
+    ///
+    /// Note that repeated invocations of this function will be memoized, so the
+    /// same `id` will always return the same resulting unique `id`.
+    fn resolve_import_module(&self, id: &str, span: Span) -> Result<ImportModule, Diagnostic> {
+        let mut files = self.files.borrow_mut();
+        if let Some(file) = files.get(id) {
+            return Ok(ImportModule::Named(self.intern_str(&file.new_identifier)));
+        }
+        self.check_for_package_json();
+        let path = if id.starts_with("/") {
+            self.root.join(&id[1..])
+        } else if id.starts_with("./") || id.starts_with("../") {
+            let msg = "relative module paths aren't supported yet";
+            return Err(Diagnostic::span_error(span, msg));
+        } else {
+            return Ok(ImportModule::RawNamed(self.intern_str(id)));
+        };
+
+        // Generate a unique ID which is somewhat readable as well, so mix in
+        // the crate name, hash to make it unique, and then the original path.
+        let new_identifier = format!("{}{}", self.unique_crate_identifier(), id);
+        let file = LocalFile {
+            path,
+            definition: span,
+            new_identifier,
+        };
+        files.insert(id.to_string(), file);
+        drop(files);
+        self.resolve_import_module(id, span)
+    }
+
+    fn unique_crate_identifier(&self) -> String {
+        format!("{}-{}", self.crate_name, ShortHash(0))
+    }
+
+    fn check_for_package_json(&self) {
+        if self.has_package_json.get() {
+            return;
+        }
+        let path = self.root.join("package.json");
+        if path.exists() {
+            self.has_package_json.set(true);
+        }
+    }
+}
+
+fn shared_program<'a>(
+    prog: &'a ast::Program,
+    intern: &'a Interner,
+) -> Result<Program<'a>, Diagnostic> {
+    Ok(Program {
+        exports: prog
+            .exports
+            .iter()
+            .map(|a| shared_export(a, intern))
+            .collect::<Result<Vec<_>, _>>()?,
+        structs: prog
+            .structs
+            .iter()
+            .map(|a| shared_struct(a, intern))
+            .collect(),
+        enums: prog.enums.iter().map(|a| shared_enum(a, intern)).collect(),
+        imports: prog
+            .imports
+            .iter()
+            .map(|a| shared_import(a, intern))
+            .collect::<Result<Vec<_>, _>>()?,
+        typescript_custom_sections: prog
+            .typescript_custom_sections
+            .iter()
+            .map(|x| -> &'a str { &x })
+            .collect(),
+        local_modules: intern
+            .files
+            .borrow()
+            .values()
+            .map(|file| {
+                fs::read_to_string(&file.path)
+                    .map(|s| LocalModule {
+                        identifier: intern.intern_str(&file.new_identifier),
+                        contents: intern.intern_str(&s),
+                    })
+                    .map_err(|e| {
+                        let msg = format!("failed to read file `{}`: {}", file.path.display(), e);
+                        Diagnostic::span_error(file.definition, msg)
+                    })
+            })
+            .collect::<Result<Vec<_>, _>>()?,
+        inline_js: prog
+            .inline_js
+            .iter()
+            .map(|js| intern.intern_str(js))
+            .collect(),
+        unique_crate_identifier: intern.intern_str(&intern.unique_crate_identifier()),
+        package_json: if intern.has_package_json.get() {
+            Some(intern.intern_str(intern.root.join("package.json").to_str().unwrap()))
+        } else {
+            None
+        },
+    })
+}
+
+fn shared_export<'a>(
+    export: &'a ast::Export,
+    intern: &'a Interner,
+) -> Result<Export<'a>, Diagnostic> {
+    let consumed = match export.method_self {
+        Some(ast::MethodSelf::ByValue) => true,
+        _ => false,
+    };
+    let method_kind = from_ast_method_kind(&export.function, intern, &export.method_kind)?;
+    Ok(Export {
+        class: export.js_class.as_ref().map(|s| &**s),
+        comments: export.comments.iter().map(|s| &**s).collect(),
+        consumed,
+        function: shared_function(&export.function, intern),
+        method_kind,
+        start: export.start,
+    })
+}
+
+fn shared_function<'a>(func: &'a ast::Function, _intern: &'a Interner) -> Function<'a> {
+    let arg_names = func
+        .arguments
+        .iter()
+        .enumerate()
+        .map(|(idx, arg)| {
+            if let syn::Pat::Ident(x) = &*arg.pat {
+                return x.ident.to_string();
+            }
+            format!("arg{}", idx)
+        })
+        .collect::<Vec<_>>();
+    Function {
+        arg_names,
+        asyncness: func.r#async,
+        name: &func.name,
+        generate_typescript: func.generate_typescript,
+        variadic: func.variadic,
+    }
+}
+
+fn shared_enum<'a>(e: &'a ast::Enum, intern: &'a Interner) -> Enum<'a> {
+    Enum {
+        name: &e.js_name,
+        variants: e
+            .variants
+            .iter()
+            .map(|v| shared_variant(v, intern))
+            .collect(),
+        comments: e.comments.iter().map(|s| &**s).collect(),
+        generate_typescript: e.generate_typescript,
+    }
+}
+
+fn shared_variant<'a>(v: &'a ast::Variant, intern: &'a Interner) -> EnumVariant<'a> {
+    EnumVariant {
+        name: intern.intern(&v.name),
+        value: v.value,
+        comments: v.comments.iter().map(|s| &**s).collect(),
+    }
+}
+
+fn shared_import<'a>(i: &'a ast::Import, intern: &'a Interner) -> Result<Import<'a>, Diagnostic> {
+    Ok(Import {
+        module: i
+            .module
+            .as_ref()
+            .map(|m| shared_module(m, intern))
+            .transpose()?,
+        js_namespace: i.js_namespace.clone(),
+        kind: shared_import_kind(&i.kind, intern)?,
+    })
+}
+
+fn shared_module<'a>(
+    m: &'a ast::ImportModule,
+    intern: &'a Interner,
+) -> Result<ImportModule<'a>, Diagnostic> {
+    Ok(match m {
+        ast::ImportModule::Named(m, span) => intern.resolve_import_module(m, *span)?,
+        ast::ImportModule::RawNamed(m, _span) => ImportModule::RawNamed(intern.intern_str(m)),
+        ast::ImportModule::Inline(idx, _) => ImportModule::Inline(*idx as u32),
+    })
+}
+
+fn shared_import_kind<'a>(
+    i: &'a ast::ImportKind,
+    intern: &'a Interner,
+) -> Result<ImportKind<'a>, Diagnostic> {
+    Ok(match i {
+        ast::ImportKind::Function(f) => ImportKind::Function(shared_import_function(f, intern)?),
+        ast::ImportKind::Static(f) => ImportKind::Static(shared_import_static(f, intern)),
+        ast::ImportKind::Type(f) => ImportKind::Type(shared_import_type(f, intern)),
+        ast::ImportKind::Enum(f) => ImportKind::Enum(shared_import_enum(f, intern)),
+    })
+}
+
+fn shared_import_function<'a>(
+    i: &'a ast::ImportFunction,
+    intern: &'a Interner,
+) -> Result<ImportFunction<'a>, Diagnostic> {
+    let method = match &i.kind {
+        ast::ImportFunctionKind::Method { class, kind, .. } => {
+            let kind = from_ast_method_kind(&i.function, intern, kind)?;
+            Some(MethodData { class, kind })
+        }
+        ast::ImportFunctionKind::Normal => None,
+    };
+
+    Ok(ImportFunction {
+        shim: intern.intern(&i.shim),
+        catch: i.catch,
+        method,
+        assert_no_shim: i.assert_no_shim,
+        structural: i.structural,
+        function: shared_function(&i.function, intern),
+        variadic: i.variadic,
+    })
+}
+
+fn shared_import_static<'a>(i: &'a ast::ImportStatic, intern: &'a Interner) -> ImportStatic<'a> {
+    ImportStatic {
+        name: &i.js_name,
+        shim: intern.intern(&i.shim),
+    }
+}
+
+fn shared_import_type<'a>(i: &'a ast::ImportType, intern: &'a Interner) -> ImportType<'a> {
+    ImportType {
+        name: &i.js_name,
+        instanceof_shim: &i.instanceof_shim,
+        vendor_prefixes: i.vendor_prefixes.iter().map(|x| intern.intern(x)).collect(),
+    }
+}
+
+fn shared_import_enum<'a>(_i: &'a ast::ImportEnum, _intern: &'a Interner) -> ImportEnum {
+    ImportEnum {}
+}
+
+fn shared_struct<'a>(s: &'a ast::Struct, intern: &'a Interner) -> Struct<'a> {
+    Struct {
+        name: &s.js_name,
+        fields: s
+            .fields
+            .iter()
+            .map(|s| shared_struct_field(s, intern))
+            .collect(),
+        comments: s.comments.iter().map(|s| &**s).collect(),
+        is_inspectable: s.is_inspectable,
+        generate_typescript: s.generate_typescript,
+    }
+}
+
+fn shared_struct_field<'a>(s: &'a ast::StructField, _intern: &'a Interner) -> StructField<'a> {
+    StructField {
+        name: &s.js_name,
+        readonly: s.readonly,
+        comments: s.comments.iter().map(|s| &**s).collect(),
+        generate_typescript: s.generate_typescript,
+    }
+}
+
+trait Encode {
+    fn encode(&self, dst: &mut Encoder);
+}
+
+struct Encoder {
+    dst: Vec<u8>,
+}
+
+impl Encoder {
+    fn new() -> Encoder {
+        Encoder {
+            dst: vec![0, 0, 0, 0],
+        }
+    }
+
+    fn finish(mut self) -> Vec<u8> {
+        let len = (self.dst.len() - 4) as u32;
+        self.dst[..4].copy_from_slice(&len.to_le_bytes()[..]);
+        self.dst
+    }
+
+    fn byte(&mut self, byte: u8) {
+        self.dst.push(byte);
+    }
+}
+
+impl Encode for bool {
+    fn encode(&self, dst: &mut Encoder) {
+        dst.byte(*self as u8);
+    }
+}
+
+impl Encode for u32 {
+    fn encode(&self, dst: &mut Encoder) {
+        let mut val = *self;
+        while (val >> 7) != 0 {
+            dst.byte((val as u8) | 0x80);
+            val >>= 7;
+        }
+        assert_eq!(val >> 7, 0);
+        dst.byte(val as u8);
+    }
+}
+
+impl Encode for usize {
+    fn encode(&self, dst: &mut Encoder) {
+        assert!(*self <= u32::max_value() as usize);
+        (*self as u32).encode(dst);
+    }
+}
+
+impl<'a> Encode for &'a [u8] {
+    fn encode(&self, dst: &mut Encoder) {
+        self.len().encode(dst);
+        dst.dst.extend_from_slice(*self);
+    }
+}
+
+impl<'a> Encode for &'a str {
+    fn encode(&self, dst: &mut Encoder) {
+        self.as_bytes().encode(dst);
+    }
+}
+
+impl<'a> Encode for String {
+    fn encode(&self, dst: &mut Encoder) {
+        self.as_bytes().encode(dst);
+    }
+}
+
+impl<T: Encode> Encode for Vec<T> {
+    fn encode(&self, dst: &mut Encoder) {
+        self.len().encode(dst);
+        for item in self {
+            item.encode(dst);
+        }
+    }
+}
+
+impl<T: Encode> Encode for Option<T> {
+    fn encode(&self, dst: &mut Encoder) {
+        match self {
+            None => dst.byte(0),
+            Some(val) => {
+                dst.byte(1);
+                val.encode(dst)
+            }
+        }
+    }
+}
+
+macro_rules! encode_struct {
+    ($name:ident ($($lt:tt)*) $($field:ident: $ty:ty,)*) => {
+        struct $name $($lt)* {
+            $($field: $ty,)*
+        }
+
+        impl $($lt)* Encode for $name $($lt)* {
+            fn encode(&self, _dst: &mut Encoder) {
+                $(self.$field.encode(_dst);)*
+            }
+        }
+    }
+}
+
+macro_rules! encode_enum {
+    ($name:ident ($($lt:tt)*) $($fields:tt)*) => (
+        enum $name $($lt)* { $($fields)* }
+
+        impl$($lt)* Encode for $name $($lt)* {
+            fn encode(&self, dst: &mut Encoder) {
+                use self::$name::*;
+                encode_enum!(@arms self dst (0) () $($fields)*)
+            }
+        }
+    );
+
+    (@arms $me:ident $dst:ident ($cnt:expr) ($($arms:tt)*)) => (
+        encode_enum!(@expr match $me { $($arms)* })
+    );
+
+    (@arms $me:ident $dst:ident ($cnt:expr) ($($arms:tt)*) $name:ident, $($rest:tt)*) => (
+        encode_enum!(
+            @arms
+            $me
+            $dst
+            ($cnt+1)
+            ($($arms)* $name => $dst.byte($cnt),)
+            $($rest)*
+        )
+    );
+
+    (@arms $me:ident $dst:ident ($cnt:expr) ($($arms:tt)*) $name:ident($t:ty), $($rest:tt)*) => (
+        encode_enum!(
+            @arms
+            $me
+            $dst
+            ($cnt+1)
+            ($($arms)* $name(val) => { $dst.byte($cnt); val.encode($dst) })
+            $($rest)*
+        )
+    );
+
+    (@expr $e:expr) => ($e);
+}
+
+macro_rules! encode_api {
+    () => ();
+    (struct $name:ident<'a> { $($fields:tt)* } $($rest:tt)*) => (
+        encode_struct!($name (<'a>) $($fields)*);
+        encode_api!($($rest)*);
+    );
+    (struct $name:ident { $($fields:tt)* } $($rest:tt)*) => (
+        encode_struct!($name () $($fields)*);
+        encode_api!($($rest)*);
+    );
+    (enum $name:ident<'a> { $($variants:tt)* } $($rest:tt)*) => (
+        encode_enum!($name (<'a>) $($variants)*);
+        encode_api!($($rest)*);
+    );
+    (enum $name:ident { $($variants:tt)* } $($rest:tt)*) => (
+        encode_enum!($name () $($variants)*);
+        encode_api!($($rest)*);
+    );
+}
+wasm_bindgen_shared::shared_api!(encode_api);
+
+fn from_ast_method_kind<'a>(
+    function: &'a ast::Function,
+    intern: &'a Interner,
+    method_kind: &'a ast::MethodKind,
+) -> Result<MethodKind<'a>, Diagnostic> {
+    Ok(match method_kind {
+        ast::MethodKind::Constructor => MethodKind::Constructor,
+        ast::MethodKind::Operation(ast::Operation { is_static, kind }) => {
+            let is_static = *is_static;
+            let kind = match kind {
+                ast::OperationKind::Getter(g) => {
+                    let g = g.as_ref().map(|g| intern.intern(g));
+                    OperationKind::Getter(g.unwrap_or_else(|| function.infer_getter_property()))
+                }
+                ast::OperationKind::Regular => OperationKind::Regular,
+                ast::OperationKind::Setter(s) => {
+                    let s = s.as_ref().map(|s| intern.intern(s));
+                    OperationKind::Setter(match s {
+                        Some(s) => s,
+                        None => intern.intern_str(&function.infer_setter_property()?),
+                    })
+                }
+                ast::OperationKind::IndexingGetter => OperationKind::IndexingGetter,
+                ast::OperationKind::IndexingSetter => OperationKind::IndexingSetter,
+                ast::OperationKind::IndexingDeleter => OperationKind::IndexingDeleter,
+            };
+            MethodKind::Operation(Operation { is_static, kind })
+        }
+    })
+}
diff --git a/vendor/wasm-bindgen-backend/src/error.rs b/vendor/wasm-bindgen-backend/src/error.rs
new file mode 100644
index 000000000..3e65cd745
--- /dev/null
+++ b/vendor/wasm-bindgen-backend/src/error.rs
@@ -0,0 +1,134 @@
+use proc_macro2::*;
+use quote::{ToTokens, TokenStreamExt};
+use syn::parse::Error;
+
+/// Provide a Diagnostic with the given span and message
+#[macro_export]
+macro_rules! err_span {
+    ($span:expr, $($msg:tt)*) => (
+        $crate::Diagnostic::spanned_error(&$span, format!($($msg)*))
+    )
+}
+
+/// Immediately fail and return an Err, with the arguments passed to err_span!
+#[macro_export]
+macro_rules! bail_span {
+    ($($t:tt)*) => (
+        return Err(err_span!($($t)*).into())
+    )
+}
+
+/// A struct representing a diagnostic to emit to the end-user as an error.
+#[derive(Debug)]
+pub struct Diagnostic {
+    inner: Repr,
+}
+
+#[derive(Debug)]
+enum Repr {
+    Single {
+        text: String,
+        span: Option<(Span, Span)>,
+    },
+    SynError(Error),
+    Multi {
+        diagnostics: Vec<Diagnostic>,
+    },
+}
+
+impl Diagnostic {
+    /// Generate a `Diagnostic` from an informational message with no Span
+    pub fn error<T: Into<String>>(text: T) -> Diagnostic {
+        Diagnostic {
+            inner: Repr::Single {
+                text: text.into(),
+                span: None,
+            },
+        }
+    }
+
+    /// Generate a `Diagnostic` from a Span and an informational message
+    pub fn span_error<T: Into<String>>(span: Span, text: T) -> Diagnostic {
+        Diagnostic {
+            inner: Repr::Single {
+                text: text.into(),
+                span: Some((span, span)),
+            },
+        }
+    }
+
+    /// Generate a `Diagnostic` from the span of any tokenizable object and a message
+    pub fn spanned_error<T: Into<String>>(node: &dyn ToTokens, text: T) -> Diagnostic {
+        Diagnostic {
+            inner: Repr::Single {
+                text: text.into(),
+                span: extract_spans(node),
+            },
+        }
+    }
+
+    /// Attempt to generate a `Diagnostic` from a vector of other `Diagnostic` instances.
+    /// If the `Vec` is empty, returns `Ok(())`, otherwise returns the new `Diagnostic`
+    pub fn from_vec(diagnostics: Vec<Diagnostic>) -> Result<(), Diagnostic> {
+        if diagnostics.len() == 0 {
+            Ok(())
+        } else {
+            Err(Diagnostic {
+                inner: Repr::Multi { diagnostics },
+            })
+        }
+    }
+
+    /// Immediately trigger a panic from this `Diagnostic`
+    #[allow(unconditional_recursion)]
+    pub fn panic(&self) -> ! {
+        match &self.inner {
+            Repr::Single { text, .. } => panic!("{}", text),
+            Repr::SynError(error) => panic!("{}", error),
+            Repr::Multi { diagnostics } => diagnostics[0].panic(),
+        }
+    }
+}
+
+impl From<Error> for Diagnostic {
+    fn from(err: Error) -> Diagnostic {
+        Diagnostic {
+            inner: Repr::SynError(err),
+        }
+    }
+}
+
+fn extract_spans(node: &dyn ToTokens) -> Option<(Span, Span)> {
+    let mut t = TokenStream::new();
+    node.to_tokens(&mut t);
+    let mut tokens = t.into_iter();
+    let start = tokens.next().map(|t| t.span());
+    let end = tokens.last().map(|t| t.span());
+    start.map(|start| (start, end.unwrap_or(start)))
+}
+
+impl ToTokens for Diagnostic {
+    fn to_tokens(&self, dst: &mut TokenStream) {
+        match &self.inner {
+            Repr::Single { text, span } => {
+                let cs2 = (Span::call_site(), Span::call_site());
+                let (start, end) = span.unwrap_or(cs2);
+                dst.append(Ident::new("compile_error", start));
+                dst.append(Punct::new('!', Spacing::Alone));
+                let mut message = TokenStream::new();
+                message.append(Literal::string(text));
+                let mut group = Group::new(Delimiter::Brace, message);
+                group.set_span(end);
+                dst.append(group);
+            }
+            Repr::Multi { diagnostics } => {
+                for diagnostic in diagnostics {
+                    diagnostic.to_tokens(dst);
+                }
+            }
+            Repr::SynError(err) => {
+                err.to_compile_error().to_tokens(dst);
+            }
+        }
+    }
+}
diff --git a/vendor/wasm-bindgen-backend/src/lib.rs b/vendor/wasm-bindgen-backend/src/lib.rs
new file mode 100644
index 000000000..d9262e857
--- /dev/null
+++ b/vendor/wasm-bindgen-backend/src/lib.rs
@@ -0,0 +1,40 @@
+//! A common backend for bindgen crates.
+//!
+//! This (internal) crate provides functionality common to multiple bindgen
+//! dependency crates. There are 4 main things exported from this crate:
+//!
+//! 1. [**`TryToTokens`**](./trait.TryToTokens.html)
+//!
+//!    Provides the ability to attempt conversion from an AST struct
+//!    into a TokenStream
+//!
+//! 2. [**`Diagnostic`**](./struct.Diagnostic.html)
+//!
+//!    A struct used to provide diagnostic responses for failures of said
+//!    tokenization
+//!
+//! 3. [**`ast`**](./ast/index.html)
+//!
+//!    Abstract Syntax Tree types used to represent a Rust program, with
+//!    the necessary metadata to generate bindings for it
+//!
+//! 4. [**`util`**](./util/index.html)
+//!
+//!    Common utilities for manipulating parsed types from syn
+//!
+
+#![recursion_limit = "256"]
+#![cfg_attr(feature = "extra-traits", deny(missing_debug_implementations))]
+#![deny(missing_docs)]
+#![doc(html_root_url = "https://docs.rs/wasm-bindgen-backend/0.2")]
+
+pub use crate::codegen::TryToTokens;
+pub use crate::error::Diagnostic;
+
+#[macro_use]
+mod error;
+
+pub mod ast;
+mod codegen;
+mod encode;
+pub mod util;
diff --git a/vendor/wasm-bindgen-backend/src/util.rs b/vendor/wasm-bindgen-backend/src/util.rs
new file mode 100644
index 000000000..1a2b07dce
--- /dev/null
+++ b/vendor/wasm-bindgen-backend/src/util.rs
@@ -0,0 +1,161 @@
+//! Common utility function for manipulating syn types and
+//! handling parsed values
+
+use std::collections::hash_map::DefaultHasher;
+use std::env;
+use std::fmt;
+use std::hash::{Hash, Hasher};
+use std::iter::FromIterator;
+use std::sync::atomic::AtomicBool;
+use std::sync::atomic::AtomicUsize;
+use std::sync::atomic::Ordering::SeqCst;
+
+use crate::ast;
+use proc_macro2::{self, Ident};
+
+/// Check whether a given `&str` is a Rust keyword
+fn is_rust_keyword(name: &str) -> bool {
+    match name {
+        "abstract" | "alignof" | "as" | "become" | "box" | "break" | "const" | "continue"
+        | "crate" | "do" | "else" | "enum" | "extern" | "false" | "final" | "fn" | "for" | "if"
+        | "impl" | "in" | "let" | "loop" | "macro" | "match" | "mod" | "move" | "mut"
+        | "offsetof" | "override" | "priv" | "proc" | "pub" | "pure" | "ref" | "return"
+        | "Self" | "self" | "sizeof" | "static" | "struct" | "super" | "trait" | "true"
+        | "type" | "typeof" | "unsafe" | "unsized" | "use" | "virtual" | "where" | "while"
+        | "yield" | "bool" | "_" => true,
+        _ => false,
+    }
+}
+
+/// Create an `Ident`, possibly mangling it if it conflicts with a Rust keyword.
+pub fn rust_ident(name: &str) -> Ident {
+    if name == "" {
+        panic!("tried to create empty Ident (from \"\")");
+    } else if is_rust_keyword(name) {
+        Ident::new(&format!("{}_", name), proc_macro2::Span::call_site())
+
+    // we didn't historically have `async` in the `is_rust_keyword` list above,
+    // so for backwards compatibility reasons we need to generate an `async`
+    // identifier as well, but we'll be sure to use a raw identifier to ease
+    // compatibility with the 2018 edition.
+    //
+    // Note, though, that `proc-macro` doesn't support a normal way to create a
+    // raw identifier. To get around that we do some wonky parsing to
+    // roundaboutly create one.
+    } else if name == "async" {
+        let ident = "r#async"
+            .parse::<proc_macro2::TokenStream>()
+            .unwrap()
+            .into_iter()
+            .next()
+            .unwrap();
+        match ident {
+            proc_macro2::TokenTree::Ident(i) => i,
+            _ => unreachable!(),
+        }
+    } else if name.chars().next().unwrap().is_ascii_digit() {
+        Ident::new(&format!("N{}", name), proc_macro2::Span::call_site())
+    } else {
+        raw_ident(name)
+    }
+}
+
+/// Create an `Ident` without checking to see if it conflicts with a Rust
+/// keyword.
+pub fn raw_ident(name: &str) -> Ident {
+    Ident::new(name, proc_macro2::Span::call_site())
+}
+
+/// Create a path type from the given segments. For example an iterator yielding
+/// the idents `[foo, bar, baz]` will result in the path type `foo::bar::baz`.
+pub fn simple_path_ty<I>(segments: I) -> syn::Type
+where
+    I: IntoIterator<Item = Ident>,
+{
+    path_ty(false, segments)
+}
+
+/// Create a global path type from the given segments. For example an iterator
+/// yielding the idents `[foo, bar, baz]` will result in the path type
+/// `::foo::bar::baz`.
+pub fn leading_colon_path_ty<I>(segments: I) -> syn::Type
+where
+    I: IntoIterator<Item = Ident>,
+{
+    path_ty(true, segments)
+}
+
+fn path_ty<I>(leading_colon: bool, segments: I) -> syn::Type
+where
+    I: IntoIterator<Item = Ident>,
+{
+    let segments: Vec<_> = segments
+        .into_iter()
+        .map(|i| syn::PathSegment {
+            ident: i,
+            arguments: syn::PathArguments::None,
+        })
+        .collect();
+
+    syn::TypePath {
+        qself: None,
+        path: syn::Path {
+            leading_colon: if leading_colon {
+                Some(Default::default())
+            } else {
+                None
+            },
+            segments: syn::punctuated::Punctuated::from_iter(segments),
+        },
+    }
+    .into()
+}
+
+/// Create a path type with a single segment from a given Identifier
+pub fn ident_ty(ident: Ident) -> syn::Type {
+    simple_path_ty(Some(ident))
+}
+
+/// Convert an ImportFunction into the more generic Import type, wrapping the provided function
+pub fn wrap_import_function(function: ast::ImportFunction) -> ast::Import {
+    ast::Import {
+        module: None,
+        js_namespace: None,
+        kind: ast::ImportKind::Function(function),
+    }
+}
+
+/// Small utility used when generating symbol names.
+///
+/// Hashes the public field here along with a few cargo-set env vars to
+/// distinguish between runs of the procedural macro.
+#[derive(Debug)]
+pub struct ShortHash<T>(pub T);
+
+impl<T: Hash> fmt::Display for ShortHash<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        static HASHED: AtomicBool = AtomicBool::new(false);
+        static HASH: AtomicUsize = AtomicUsize::new(0);
+
+        // Try to amortize the cost of loading env vars a lot as we're gonna be
+        // hashing for a lot of symbols.
+        if !HASHED.load(SeqCst) {
+            let mut h = DefaultHasher::new();
+            env::var("CARGO_PKG_NAME")
+                .expect("should have CARGO_PKG_NAME env var")
+                .hash(&mut h);
+            env::var("CARGO_PKG_VERSION")
+                .expect("should have CARGO_PKG_VERSION env var")
+                .hash(&mut h);
+            // This may chop off 32 bits on 32-bit platforms, but that's ok, we
+            // just want something to mix in below anyway.
+            HASH.store(h.finish() as usize, SeqCst);
+            HASHED.store(true, SeqCst);
+        }
+
+        let mut h = DefaultHasher::new();
+        HASH.load(SeqCst).hash(&mut h);
+        self.0.hash(&mut h);
+        write!(f, "{:016x}", h.finish())
+    }
+}